diff --git a/bin/rimraf-standalone.js b/bin/rimraf-standalone.js
new file mode 100644
index 00000000..2a770410
--- /dev/null
+++ b/bin/rimraf-standalone.js
@@ -0,0 +1,3716 @@
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var assert = _interopDefault(require('assert'));
+var require$$0 = _interopDefault(require('path'));
+var fs = _interopDefault(require('fs'));
+var util = _interopDefault(require('util'));
+var events = _interopDefault(require('events'));
+
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+var pathModule = require$$0;
+var isWindows$1 = process.platform === 'win32';
+var fs$4 = fs;
+
+// JavaScript implementation of realpath, ported from node pre-v6
+
+var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
+
+function rethrow() {
+  // Only enable in debug mode. A backtrace uses ~1000 bytes of heap space and
+  // is fairly slow to generate.
+  var callback;
+  if (DEBUG) {
+    var backtrace = new Error;
+    callback = debugCallback;
+  } else
+    callback = missingCallback;
+
+  return callback;
+
+  function debugCallback(err) {
+    if (err) {
+      backtrace.message = err.message;
+      err = backtrace;
+      missingCallback(err);
+    }
+  }
+
+  function missingCallback(err) {
+    if (err) {
+      if (process.throwDeprecation)
+        throw err;  // Forgot a callback but don't know where? Use NODE_DEBUG=fs
+      else if (!process.noDeprecation) {
+        var msg = 'fs: missing callback ' + (err.stack || err.message);
+        if (process.traceDeprecation)
+          console.trace(msg);
+        else
+          console.error(msg);
+      }
+    }
+  }
+}
+
+function maybeCallback(cb) {
+  return typeof cb === 'function' ? cb : rethrow();
+}
+
+// Regexp that finds the next partion of a (partial) path
+// result is [base_with_slash, base], e.g. ['somedir/', 'somedir']
+if (isWindows$1) {
+  var nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
+} else {
+  var nextPartRe = /(.*?)(?:[\/]+|$)/g;
+}
+
+// Regex to find the device root, including trailing slash. E.g. 'c:\\'.
+if (isWindows$1) {
+  var splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
+} else {
+  var splitRootRe = /^[\/]*/;
+}
+
+var realpathSync$1 = function realpathSync(p, cache) {
+  // make p is absolute
+  p = pathModule.resolve(p);
+
+  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+    return cache[p];
+  }
+
+  var original = p,
+      seenLinks = {},
+      knownHard = {};
+
+  // current character position in p
+  var pos;
+  // the partial path so far, including a trailing slash if any
+  var current;
+  // the partial path without a trailing slash (except when pointing at a root)
+  var base;
+  // the partial path scanned in the previous round, with slash
+  var previous;
+
+  start();
+
+  function start() {
+    // Skip over roots
+    var m = splitRootRe.exec(p);
+    pos = m[0].length;
+    current = m[0];
+    base = m[0];
+    previous = '';
+
+    // On windows, check that the root exists. On unix there is no need.
+    if (isWindows$1 && !knownHard[base]) {
+      fs$4.lstatSync(base);
+      knownHard[base] = true;
+    }
+  }
+
+  // walk down the path, swapping out linked pathparts for their real
+  // values
+  // NB: p.length changes.
+  while (pos < p.length) {
+    // find the next part
+    nextPartRe.lastIndex = pos;
+    var result = nextPartRe.exec(p);
+    previous = current;
+    current += result[0];
+    base = previous + result[1];
+    pos = nextPartRe.lastIndex;
+
+    // continue if not a symlink
+    if (knownHard[base] || (cache && cache[base] === base)) {
+      continue;
+    }
+
+    var resolvedLink;
+    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+      // some known symbolic link.  no need to stat again.
+      resolvedLink = cache[base];
+    } else {
+      var stat = fs$4.lstatSync(base);
+      if (!stat.isSymbolicLink()) {
+        knownHard[base] = true;
+        if (cache) cache[base] = base;
+        continue;
+      }
+
+      // read the link if it wasn't read before
+      // dev/ino always return 0 on windows, so skip the check.
+      var linkTarget = null;
+      if (!isWindows$1) {
+        var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+        if (seenLinks.hasOwnProperty(id)) {
+          linkTarget = seenLinks[id];
+        }
+      }
+      if (linkTarget === null) {
+        fs$4.statSync(base);
+        linkTarget = fs$4.readlinkSync(base);
+      }
+      resolvedLink = pathModule.resolve(previous, linkTarget);
+      // track this, if given a cache.
+      if (cache) cache[base] = resolvedLink;
+      if (!isWindows$1) seenLinks[id] = linkTarget;
+    }
+
+    // resolve the link, then start over
+    p = pathModule.resolve(resolvedLink, p.slice(pos));
+    start();
+  }
+
+  if (cache) cache[original] = p;
+
+  return p;
+};
+
+
+var realpath$1 = function realpath(p, cache, cb) {
+  if (typeof cb !== 'function') {
+    cb = maybeCallback(cache);
+    cache = null;
+  }
+
+  // make p is absolute
+  p = pathModule.resolve(p);
+
+  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
+    return process.nextTick(cb.bind(null, null, cache[p]));
+  }
+
+  var original = p,
+      seenLinks = {},
+      knownHard = {};
+
+  // current character position in p
+  var pos;
+  // the partial path so far, including a trailing slash if any
+  var current;
+  // the partial path without a trailing slash (except when pointing at a root)
+  var base;
+  // the partial path scanned in the previous round, with slash
+  var previous;
+
+  start();
+
+  function start() {
+    // Skip over roots
+    var m = splitRootRe.exec(p);
+    pos = m[0].length;
+    current = m[0];
+    base = m[0];
+    previous = '';
+
+    // On windows, check that the root exists. On unix there is no need.
+    if (isWindows$1 && !knownHard[base]) {
+      fs$4.lstat(base, function(err) {
+        if (err) return cb(err);
+        knownHard[base] = true;
+        LOOP();
+      });
+    } else {
+      process.nextTick(LOOP);
+    }
+  }
+
+  // walk down the path, swapping out linked pathparts for their real
+  // values
+  function LOOP() {
+    // stop if scanned past end of path
+    if (pos >= p.length) {
+      if (cache) cache[original] = p;
+      return cb(null, p);
+    }
+
+    // find the next part
+    nextPartRe.lastIndex = pos;
+    var result = nextPartRe.exec(p);
+    previous = current;
+    current += result[0];
+    base = previous + result[1];
+    pos = nextPartRe.lastIndex;
+
+    // continue if not a symlink
+    if (knownHard[base] || (cache && cache[base] === base)) {
+      return process.nextTick(LOOP);
+    }
+
+    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
+      // known symbolic link.  no need to stat again.
+      return gotResolvedLink(cache[base]);
+    }
+
+    return fs$4.lstat(base, gotStat);
+  }
+
+  function gotStat(err, stat) {
+    if (err) return cb(err);
+
+    // if not a symlink, skip to the next path part
+    if (!stat.isSymbolicLink()) {
+      knownHard[base] = true;
+      if (cache) cache[base] = base;
+      return process.nextTick(LOOP);
+    }
+
+    // stat & read the link if not read before
+    // call gotTarget as soon as the link target is known
+    // dev/ino always return 0 on windows, so skip the check.
+    if (!isWindows$1) {
+      var id = stat.dev.toString(32) + ':' + stat.ino.toString(32);
+      if (seenLinks.hasOwnProperty(id)) {
+        return gotTarget(null, seenLinks[id], base);
+      }
+    }
+    fs$4.stat(base, function(err) {
+      if (err) return cb(err);
+
+      fs$4.readlink(base, function(err, target) {
+        if (!isWindows$1) seenLinks[id] = target;
+        gotTarget(err, target);
+      });
+    });
+  }
+
+  function gotTarget(err, target, base) {
+    if (err) return cb(err);
+
+    var resolvedLink = pathModule.resolve(previous, target);
+    if (cache) cache[base] = resolvedLink;
+    gotResolvedLink(resolvedLink);
+  }
+
+  function gotResolvedLink(resolvedLink) {
+    // resolve the link, then start over
+    p = pathModule.resolve(resolvedLink, p.slice(pos));
+    start();
+  }
+};
+
+var old$1 = {
+	realpathSync: realpathSync$1,
+	realpath: realpath$1
+};
+
+var index = realpath;
+realpath.realpath = realpath;
+realpath.sync = realpathSync;
+realpath.realpathSync = realpathSync;
+realpath.monkeypatch = monkeypatch;
+realpath.unmonkeypatch = unmonkeypatch;
+
+var fs$3 = fs;
+var origRealpath = fs$3.realpath;
+var origRealpathSync = fs$3.realpathSync;
+
+var version = process.version;
+var ok = /^v[0-5]\./.test(version);
+var old = old$1;
+
+function newError (er) {
+  return er && er.syscall === 'realpath' && (
+    er.code === 'ELOOP' ||
+    er.code === 'ENOMEM' ||
+    er.code === 'ENAMETOOLONG'
+  )
+}
+
+function realpath (p, cache, cb) {
+  if (ok) {
+    return origRealpath(p, cache, cb)
+  }
+
+  if (typeof cache === 'function') {
+    cb = cache;
+    cache = null;
+  }
+  origRealpath(p, cache, function (er, result) {
+    if (newError(er)) {
+      old.realpath(p, cache, cb);
+    } else {
+      cb(er, result);
+    }
+  });
+}
+
+function realpathSync (p, cache) {
+  if (ok) {
+    return origRealpathSync(p, cache)
+  }
+
+  try {
+    return origRealpathSync(p, cache)
+  } catch (er) {
+    if (newError(er)) {
+      return old.realpathSync(p, cache)
+    } else {
+      throw er
+    }
+  }
+}
+
+function monkeypatch () {
+  fs$3.realpath = realpath;
+  fs$3.realpathSync = realpathSync;
+}
+
+function unmonkeypatch () {
+  fs$3.realpath = origRealpath;
+  fs$3.realpathSync = origRealpathSync;
+}
+
+var index$4 = function (xs, fn) {
+    var res = [];
+    for (var i = 0; i < xs.length; i++) {
+        var x = fn(xs[i], i);
+        if (isArray(x)) res.push.apply(res, x);
+        else res.push(x);
+    }
+    return res;
+};
+
+var isArray = Array.isArray || function (xs) {
+    return Object.prototype.toString.call(xs) === '[object Array]';
+};
+
+var index$6 = balanced$1;
+function balanced$1(a, b, str) {
+  if (a instanceof RegExp) a = maybeMatch(a, str);
+  if (b instanceof RegExp) b = maybeMatch(b, str);
+
+  var r = range(a, b, str);
+
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + a.length, r[1]),
+    post: str.slice(r[1] + b.length)
+  };
+}
+
+function maybeMatch(reg, str) {
+  var m = str.match(reg);
+  return m ? m[0] : null;
+}
+
+balanced$1.range = range;
+function range(a, b, str) {
+  var begs, beg, left, right, result;
+  var ai = str.indexOf(a);
+  var bi = str.indexOf(b, ai + 1);
+  var i = ai;
+
+  if (ai >= 0 && bi > 0) {
+    begs = [];
+    left = str.length;
+
+    while (i >= 0 && !result) {
+      if (i == ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length == 1) {
+        result = [ begs.pop(), bi ];
+      } else {
+        beg = begs.pop();
+        if (beg < left) {
+          left = beg;
+          right = bi;
+        }
+
+        bi = str.indexOf(b, i + 1);
+      }
+
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+
+    if (begs.length) {
+      result = [ left, right ];
+    }
+  }
+
+  return result;
+}
+
+var concatMap = index$4;
+var balanced = index$6;
+
+var index$2 = expandTop;
+
+var escSlash = '\0SLASH'+Math.random()+'\0';
+var escOpen = '\0OPEN'+Math.random()+'\0';
+var escClose = '\0CLOSE'+Math.random()+'\0';
+var escComma = '\0COMMA'+Math.random()+'\0';
+var escPeriod = '\0PERIOD'+Math.random()+'\0';
+
+function numeric(str) {
+  return parseInt(str, 10) == str
+    ? parseInt(str, 10)
+    : str.charCodeAt(0);
+}
+
+function escapeBraces(str) {
+  return str.split('\\\\').join(escSlash)
+            .split('\\{').join(escOpen)
+            .split('\\}').join(escClose)
+            .split('\\,').join(escComma)
+            .split('\\.').join(escPeriod);
+}
+
+function unescapeBraces(str) {
+  return str.split(escSlash).join('\\')
+            .split(escOpen).join('{')
+            .split(escClose).join('}')
+            .split(escComma).join(',')
+            .split(escPeriod).join('.');
+}
+
+
+// Basically just str.split(","), but handling cases
+// where we have nested braced sections, which should be
+// treated as individual members, like {a,{b,c},d}
+function parseCommaParts(str) {
+  if (!str)
+    return [''];
+
+  var parts = [];
+  var m = balanced('{', '}', str);
+
+  if (!m)
+    return str.split(',');
+
+  var pre = m.pre;
+  var body = m.body;
+  var post = m.post;
+  var p = pre.split(',');
+
+  p[p.length-1] += '{' + body + '}';
+  var postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length-1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+
+  parts.push.apply(parts, p);
+
+  return parts;
+}
+
+function expandTop(str) {
+  if (!str)
+    return [];
+
+  // I don't know why Bash 4.3 does this, but it does.
+  // Anything starting with {} will have the first two bytes preserved
+  // but *only* at the top level, so {},a}b will not expand to anything,
+  // but a{},b}c will be expanded to [a}c,abc].
+  // One could argue that this is a bug in Bash, but since the goal of
+  // this module is to match Bash's rules, we escape a leading {}
+  if (str.substr(0, 2) === '{}') {
+    str = '\\{\\}' + str.substr(2);
+  }
+
+  return expand$1(escapeBraces(str), true).map(unescapeBraces);
+}
+
+function embrace(str) {
+  return '{' + str + '}';
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+
+function expand$1(str, isTop) {
+  var expansions = [];
+
+  var m = balanced('{', '}', str);
+  if (!m || /\$$/.test(m.pre)) return [str];
+
+  var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+  var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+  var isSequence = isNumericSequence || isAlphaSequence;
+  var isOptions = /^(.*,)+(.+)?$/.test(m.body);
+  if (!isSequence && !isOptions) {
+    // {a},b}
+    if (m.post.match(/,.*\}/)) {
+      str = m.pre + '{' + m.body + escClose + m.post;
+      return expand$1(str);
+    }
+    return [str];
+  }
+
+  var n;
+  if (isSequence) {
+    n = m.body.split(/\.\./);
+  } else {
+    n = parseCommaParts(m.body);
+    if (n.length === 1) {
+      // x{{a,b}}y ==> x{a}y x{b}y
+      n = expand$1(n[0], false).map(embrace);
+      if (n.length === 1) {
+        var post = m.post.length
+          ? expand$1(m.post, false)
+          : [''];
+        return post.map(function(p) {
+          return m.pre + n[0] + p;
+        });
+      }
+    }
+  }
+
+  // at this point, n is the parts, and we know it's not a comma set
+  // with a single entry.
+
+  // no need to expand pre, since it is guaranteed to be free of brace-sets
+  var pre = m.pre;
+  var post = m.post.length
+    ? expand$1(m.post, false)
+    : [''];
+
+  var N;
+
+  if (isSequence) {
+    var x = numeric(n[0]);
+    var y = numeric(n[1]);
+    var width = Math.max(n[0].length, n[1].length);
+    var incr = n.length == 3
+      ? Math.abs(numeric(n[2]))
+      : 1;
+    var test = lte;
+    var reverse = y < x;
+    if (reverse) {
+      incr *= -1;
+      test = gte;
+    }
+    var pad = n.some(isPadded);
+
+    N = [];
+
+    for (var i = x; test(i, y); i += incr) {
+      var c;
+      if (isAlphaSequence) {
+        c = String.fromCharCode(i);
+        if (c === '\\')
+          c = '';
+      } else {
+        c = String(i);
+        if (pad) {
+          var need = width - c.length;
+          if (need > 0) {
+            var z = new Array(need + 1).join('0');
+            if (i < 0)
+              c = '-' + z + c.slice(1);
+            else
+              c = z + c;
+          }
+        }
+      }
+      N.push(c);
+    }
+  } else {
+    N = concatMap(n, function(el) { return expand$1(el, false) });
+  }
+
+  for (var j = 0; j < N.length; j++) {
+    for (var k = 0; k < post.length; k++) {
+      var expansion = pre + N[j] + post[k];
+      if (!isTop || isSequence || expansion)
+        expansions.push(expansion);
+    }
+  }
+
+  return expansions;
+}
+
+var minimatch_1 = minimatch$1;
+minimatch$1.Minimatch = Minimatch$1;
+
+var path$2 = { sep: '/' };
+try {
+  path$2 = require$$0;
+} catch (er) {}
+
+var GLOBSTAR = minimatch$1.GLOBSTAR = Minimatch$1.GLOBSTAR = {};
+var expand = index$2;
+
+var plTypes = {
+  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+  '?': { open: '(?:', close: ')?' },
+  '+': { open: '(?:', close: ')+' },
+  '*': { open: '(?:', close: ')*' },
+  '@': { open: '(?:', close: ')' }
+};
+
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]';
+
+// * => any number of characters
+var star = qmark + '*?';
+
+// ** when dots are allowed.  Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?';
+
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?';
+
+// characters that need to be escaped in RegExp.
+var reSpecials = charSet('().*{}+?[]^$\\!');
+
+// "abc" -> { a:true, b:true, c:true }
+function charSet (s) {
+  return s.split('').reduce(function (set, c) {
+    set[c] = true;
+    return set
+  }, {})
+}
+
+// normalizes slashes.
+var slashSplit = /\/+/;
+
+minimatch$1.filter = filter;
+function filter (pattern, options) {
+  options = options || {};
+  return function (p, i, list) {
+    return minimatch$1(p, pattern, options)
+  }
+}
+
+function ext (a, b) {
+  a = a || {};
+  b = b || {};
+  var t = {};
+  Object.keys(b).forEach(function (k) {
+    t[k] = b[k];
+  });
+  Object.keys(a).forEach(function (k) {
+    t[k] = a[k];
+  });
+  return t
+}
+
+minimatch$1.defaults = function (def) {
+  if (!def || !Object.keys(def).length) return minimatch$1
+
+  var orig = minimatch$1;
+
+  var m = function minimatch (p, pattern, options) {
+    return orig.minimatch(p, pattern, ext(def, options))
+  };
+
+  m.Minimatch = function Minimatch (pattern, options) {
+    return new orig.Minimatch(pattern, ext(def, options))
+  };
+
+  return m
+};
+
+Minimatch$1.defaults = function (def) {
+  if (!def || !Object.keys(def).length) return Minimatch$1
+  return minimatch$1.defaults(def).Minimatch
+};
+
+function minimatch$1 (p, pattern, options) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('glob pattern string required')
+  }
+
+  if (!options) options = {};
+
+  // shortcut: comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    return false
+  }
+
+  // "" only matches ""
+  if (pattern.trim() === '') return p === ''
+
+  return new Minimatch$1(pattern, options).match(p)
+}
+
+function Minimatch$1 (pattern, options) {
+  if (!(this instanceof Minimatch$1)) {
+    return new Minimatch$1(pattern, options)
+  }
+
+  if (typeof pattern !== 'string') {
+    throw new TypeError('glob pattern string required')
+  }
+
+  if (!options) options = {};
+  pattern = pattern.trim();
+
+  // windows support: need to use /, not \
+  if (path$2.sep !== '/') {
+    pattern = pattern.split(path$2.sep).join('/');
+  }
+
+  this.options = options;
+  this.set = [];
+  this.pattern = pattern;
+  this.regexp = null;
+  this.negate = false;
+  this.comment = false;
+  this.empty = false;
+
+  // make the set of regexps etc.
+  this.make();
+}
+
+Minimatch$1.prototype.debug = function () {};
+
+Minimatch$1.prototype.make = make;
+function make () {
+  // don't do it more than once.
+  if (this._made) return
+
+  var pattern = this.pattern;
+  var options = this.options;
+
+  // empty patterns and comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    this.comment = true;
+    return
+  }
+  if (!pattern) {
+    this.empty = true;
+    return
+  }
+
+  // step 1: figure out negation, etc.
+  this.parseNegate();
+
+  // step 2: expand braces
+  var set = this.globSet = this.braceExpand();
+
+  if (options.debug) this.debug = console.error;
+
+  this.debug(this.pattern, set);
+
+  // step 3: now we have a set, so turn each one into a series of path-portion
+  // matching patterns.
+  // These will be regexps, except in the case of "**", which is
+  // set to the GLOBSTAR object for globstar behavior,
+  // and will not contain any / characters
+  set = this.globParts = set.map(function (s) {
+    return s.split(slashSplit)
+  });
+
+  this.debug(this.pattern, set);
+
+  // glob --> regexps
+  set = set.map(function (s, si, set) {
+    return s.map(this.parse, this)
+  }, this);
+
+  this.debug(this.pattern, set);
+
+  // filter out everything that didn't compile properly.
+  set = set.filter(function (s) {
+    return s.indexOf(false) === -1
+  });
+
+  this.debug(this.pattern, set);
+
+  this.set = set;
+}
+
+Minimatch$1.prototype.parseNegate = parseNegate;
+function parseNegate () {
+  var pattern = this.pattern;
+  var negate = false;
+  var options = this.options;
+  var negateOffset = 0;
+
+  if (options.nonegate) return
+
+  for (var i = 0, l = pattern.length
+    ; i < l && pattern.charAt(i) === '!'
+    ; i++) {
+    negate = !negate;
+    negateOffset++;
+  }
+
+  if (negateOffset) this.pattern = pattern.substr(negateOffset);
+  this.negate = negate;
+}
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+minimatch$1.braceExpand = function (pattern, options) {
+  return braceExpand(pattern, options)
+};
+
+Minimatch$1.prototype.braceExpand = braceExpand;
+
+function braceExpand (pattern, options) {
+  if (!options) {
+    if (this instanceof Minimatch$1) {
+      options = this.options;
+    } else {
+      options = {};
+    }
+  }
+
+  pattern = typeof pattern === 'undefined'
+    ? this.pattern : pattern;
+
+  if (typeof pattern === 'undefined') {
+    throw new TypeError('undefined pattern')
+  }
+
+  if (options.nobrace ||
+    !pattern.match(/\{.*\}/)) {
+    // shortcut. no need to expand.
+    return [pattern]
+  }
+
+  return expand(pattern)
+}
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion.  Otherwise, any series
+// of * is equivalent to a single *.  Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+Minimatch$1.prototype.parse = parse;
+var SUBPARSE = {};
+function parse (pattern, isSub) {
+  if (pattern.length > 1024 * 64) {
+    throw new TypeError('pattern is too long')
+  }
+
+  var options = this.options;
+
+  // shortcuts
+  if (!options.noglobstar && pattern === '**') return GLOBSTAR
+  if (pattern === '') return ''
+
+  var re = '';
+  var hasMagic = !!options.nocase;
+  var escaping = false;
+  // ? => one single character
+  var patternListStack = [];
+  var negativeLists = [];
+  var stateChar;
+  var inClass = false;
+  var reClassStart = -1;
+  var classStart = -1;
+  // . and .. never match anything that doesn't start with .,
+  // even when options.dot is set.
+  var patternStart = pattern.charAt(0) === '.' ? '' // anything
+  // not (start or / followed by . or .. followed by / or end)
+  : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+  : '(?!\\.)';
+  var self = this;
+
+  function clearStateChar () {
+    if (stateChar) {
+      // we had some state-tracking character
+      // that wasn't consumed by this pass.
+      switch (stateChar) {
+        case '*':
+          re += star;
+          hasMagic = true;
+        break
+        case '?':
+          re += qmark;
+          hasMagic = true;
+        break
+        default:
+          re += '\\' + stateChar;
+        break
+      }
+      self.debug('clearStateChar %j %j', stateChar, re);
+      stateChar = false;
+    }
+  }
+
+  for (var i = 0, len = pattern.length, c
+    ; (i < len) && (c = pattern.charAt(i))
+    ; i++) {
+    this.debug('%s\t%s %s %j', pattern, i, re, c);
+
+    // skip over any that are escaped.
+    if (escaping && reSpecials[c]) {
+      re += '\\' + c;
+      escaping = false;
+      continue
+    }
+
+    switch (c) {
+      case '/':
+        // completely not allowed, even escaped.
+        // Should already be path-split by now.
+        return false
+
+      case '\\':
+        clearStateChar();
+        escaping = true;
+      continue
+
+      // the various stateChar values
+      // for the "extglob" stuff.
+      case '?':
+      case '*':
+      case '+':
+      case '@':
+      case '!':
+        this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c);
+
+        // all of those are literals inside a class, except that
+        // the glob [!a] means [^a] in regexp
+        if (inClass) {
+          this.debug('  in class');
+          if (c === '!' && i === classStart + 1) c = '^';
+          re += c;
+          continue
+        }
+
+        // if we already have a stateChar, then it means
+        // that there was something like ** or +? in there.
+        // Handle the stateChar, then proceed with this one.
+        self.debug('call clearStateChar %j', stateChar);
+        clearStateChar();
+        stateChar = c;
+        // if extglob is disabled, then +(asdf|foo) isn't a thing.
+        // just clear the statechar *now*, rather than even diving into
+        // the patternList stuff.
+        if (options.noext) clearStateChar();
+      continue
+
+      case '(':
+        if (inClass) {
+          re += '(';
+          continue
+        }
+
+        if (!stateChar) {
+          re += '\\(';
+          continue
+        }
+
+        patternListStack.push({
+          type: stateChar,
+          start: i - 1,
+          reStart: re.length,
+          open: plTypes[stateChar].open,
+          close: plTypes[stateChar].close
+        });
+        // negation is (?:(?!js)[^/]*)
+        re += stateChar === '!' ? '(?:(?!(?:' : '(?:';
+        this.debug('plType %j %j', stateChar, re);
+        stateChar = false;
+      continue
+
+      case ')':
+        if (inClass || !patternListStack.length) {
+          re += '\\)';
+          continue
+        }
+
+        clearStateChar();
+        hasMagic = true;
+        var pl = patternListStack.pop();
+        // negation is (?:(?!js)[^/]*)
+        // The others are (?:<pattern>)<type>
+        re += pl.close;
+        if (pl.type === '!') {
+          negativeLists.push(pl);
+        }
+        pl.reEnd = re.length;
+      continue
+
+      case '|':
+        if (inClass || !patternListStack.length || escaping) {
+          re += '\\|';
+          escaping = false;
+          continue
+        }
+
+        clearStateChar();
+        re += '|';
+      continue
+
+      // these are mostly the same in regexp and glob
+      case '[':
+        // swallow any state-tracking char before the [
+        clearStateChar();
+
+        if (inClass) {
+          re += '\\' + c;
+          continue
+        }
+
+        inClass = true;
+        classStart = i;
+        reClassStart = re.length;
+        re += c;
+      continue
+
+      case ']':
+        //  a right bracket shall lose its special
+        //  meaning and represent itself in
+        //  a bracket expression if it occurs
+        //  first in the list.  -- POSIX.2 2.8.3.2
+        if (i === classStart + 1 || !inClass) {
+          re += '\\' + c;
+          escaping = false;
+          continue
+        }
+
+        // handle the case where we left a class open.
+        // "[z-a]" is valid, equivalent to "\[z-a\]"
+        if (inClass) {
+          // split where the last [ was, make sure we don't have
+          // an invalid re. if so, re-walk the contents of the
+          // would-be class to re-translate any characters that
+          // were passed through as-is
+          // TODO: It would probably be faster to determine this
+          // without a try/catch and a new RegExp, but it's tricky
+          // to do safely.  For now, this is safe and works.
+          var cs = pattern.substring(classStart + 1, i);
+          try {
+            RegExp('[' + cs + ']');
+          } catch (er) {
+            // not a valid class!
+            var sp = this.parse(cs, SUBPARSE);
+            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]';
+            hasMagic = hasMagic || sp[1];
+            inClass = false;
+            continue
+          }
+        }
+
+        // finish up the class.
+        hasMagic = true;
+        inClass = false;
+        re += c;
+      continue
+
+      default:
+        // swallow any state char that wasn't consumed
+        clearStateChar();
+
+        if (escaping) {
+          // no need
+          escaping = false;
+        } else if (reSpecials[c]
+          && !(c === '^' && inClass)) {
+          re += '\\';
+        }
+
+        re += c;
+
+    } // switch
+  } // for
+
+  // handle the case where we left a class open.
+  // "[abc" is valid, equivalent to "\[abc"
+  if (inClass) {
+    // split where the last [ was, and escape it
+    // this is a huge pita.  We now have to re-walk
+    // the contents of the would-be class to re-translate
+    // any characters that were passed through as-is
+    cs = pattern.substr(classStart + 1);
+    sp = this.parse(cs, SUBPARSE);
+    re = re.substr(0, reClassStart) + '\\[' + sp[0];
+    hasMagic = hasMagic || sp[1];
+  }
+
+  // handle the case where we had a +( thing at the *end*
+  // of the pattern.
+  // each pattern list stack adds 3 chars, and we need to go through
+  // and escape any | chars that were passed through as-is for the regexp.
+  // Go through and escape them, taking care not to double-escape any
+  // | chars that were already escaped.
+  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+    var tail = re.slice(pl.reStart + pl.open.length);
+    this.debug('setting tail', re, pl);
+    // maybe some even number of \, then maybe 1 \, followed by a |
+    tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
+      if (!$2) {
+        // the | isn't already escaped, so escape it.
+        $2 = '\\';
+      }
+
+      // need to escape all those slashes *again*, without escaping the
+      // one that we need for escaping the | character.  As it works out,
+      // escaping an even number of slashes can be done by simply repeating
+      // it exactly after itself.  That's why this trick works.
+      //
+      // I am sorry that you have to see this.
+      return $1 + $1 + $2 + '|'
+    });
+
+    this.debug('tail=%j\n   %s', tail, tail, pl, re);
+    var t = pl.type === '*' ? star
+      : pl.type === '?' ? qmark
+      : '\\' + pl.type;
+
+    hasMagic = true;
+    re = re.slice(0, pl.reStart) + t + '\\(' + tail;
+  }
+
+  // handle trailing things that only matter at the very end.
+  clearStateChar();
+  if (escaping) {
+    // trailing \\
+    re += '\\\\';
+  }
+
+  // only need to apply the nodot start if the re starts with
+  // something that could conceivably capture a dot
+  var addPatternStart = false;
+  switch (re.charAt(0)) {
+    case '.':
+    case '[':
+    case '(': addPatternStart = true;
+  }
+
+  // Hack to work around lack of negative lookbehind in JS
+  // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+  // like 'a.xyz.yz' doesn't match.  So, the first negative
+  // lookahead, has to look ALL the way ahead, to the end of
+  // the pattern.
+  for (var n = negativeLists.length - 1; n > -1; n--) {
+    var nl = negativeLists[n];
+
+    var nlBefore = re.slice(0, nl.reStart);
+    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8);
+    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd);
+    var nlAfter = re.slice(nl.reEnd);
+
+    nlLast += nlAfter;
+
+    // Handle nested stuff like *(*.js|!(*.json)), where open parens
+    // mean that we should *not* include the ) in the bit that is considered
+    // "after" the negated section.
+    var openParensBefore = nlBefore.split('(').length - 1;
+    var cleanAfter = nlAfter;
+    for (i = 0; i < openParensBefore; i++) {
+      cleanAfter = cleanAfter.replace(/\)[+*?]?/, '');
+    }
+    nlAfter = cleanAfter;
+
+    var dollar = '';
+    if (nlAfter === '' && isSub !== SUBPARSE) {
+      dollar = '$';
+    }
+    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast;
+    re = newRe;
+  }
+
+  // if the re is not "" at this point, then we need to make sure
+  // it doesn't match against an empty path part.
+  // Otherwise a/* will match a/, which it should not.
+  if (re !== '' && hasMagic) {
+    re = '(?=.)' + re;
+  }
+
+  if (addPatternStart) {
+    re = patternStart + re;
+  }
+
+  // parsing just a piece of a larger pattern.
+  if (isSub === SUBPARSE) {
+    return [re, hasMagic]
+  }
+
+  // skip the regexp for non-magical patterns
+  // unescape anything in it, though, so that it'll be
+  // an exact match against a file etc.
+  if (!hasMagic) {
+    return globUnescape(pattern)
+  }
+
+  var flags = options.nocase ? 'i' : '';
+  try {
+    var regExp = new RegExp('^' + re + '$', flags);
+  } catch (er) {
+    // If it was an invalid regular expression, then it can't match
+    // anything.  This trick looks for a character after the end of
+    // the string, which is of course impossible, except in multi-line
+    // mode, but it's not a /m regex.
+    return new RegExp('$.')
+  }
+
+  regExp._glob = pattern;
+  regExp._src = re;
+
+  return regExp
+}
+
+minimatch$1.makeRe = function (pattern, options) {
+  return new Minimatch$1(pattern, options || {}).makeRe()
+};
+
+Minimatch$1.prototype.makeRe = makeRe;
+function makeRe () {
+  if (this.regexp || this.regexp === false) return this.regexp
+
+  // at this point, this.set is a 2d array of partial
+  // pattern strings, or "**".
+  //
+  // It's better to use .match().  This function shouldn't
+  // be used, really, but it's pretty convenient sometimes,
+  // when you just want to work with a regex.
+  var set = this.set;
+
+  if (!set.length) {
+    this.regexp = false;
+    return this.regexp
+  }
+  var options = this.options;
+
+  var twoStar = options.noglobstar ? star
+    : options.dot ? twoStarDot
+    : twoStarNoDot;
+  var flags = options.nocase ? 'i' : '';
+
+  var re = set.map(function (pattern) {
+    return pattern.map(function (p) {
+      return (p === GLOBSTAR) ? twoStar
+      : (typeof p === 'string') ? regExpEscape(p)
+      : p._src
+    }).join('\\\/')
+  }).join('|');
+
+  // must match entire pattern
+  // ending in a * or ** will make it less strict.
+  re = '^(?:' + re + ')$';
+
+  // can match anything, as long as it's not this.
+  if (this.negate) re = '^(?!' + re + ').*$';
+
+  try {
+    this.regexp = new RegExp(re, flags);
+  } catch (ex) {
+    this.regexp = false;
+  }
+  return this.regexp
+}
+
+minimatch$1.match = function (list, pattern, options) {
+  options = options || {};
+  var mm = new Minimatch$1(pattern, options);
+  list = list.filter(function (f) {
+    return mm.match(f)
+  });
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
+  }
+  return list
+};
+
+Minimatch$1.prototype.match = match;
+function match (f, partial) {
+  this.debug('match', f, this.pattern);
+  // short-circuit in the case of busted things.
+  // comments, etc.
+  if (this.comment) return false
+  if (this.empty) return f === ''
+
+  if (f === '/' && partial) return true
+
+  var options = this.options;
+
+  // windows: need to use /, not \
+  if (path$2.sep !== '/') {
+    f = f.split(path$2.sep).join('/');
+  }
+
+  // treat the test path as a set of pathparts.
+  f = f.split(slashSplit);
+  this.debug(this.pattern, 'split', f);
+
+  // just ONE of the pattern sets in this.set needs to match
+  // in order for it to be valid.  If negating, then just one
+  // match means that we have failed.
+  // Either way, return on the first hit.
+
+  var set = this.set;
+  this.debug(this.pattern, 'set', set);
+
+  // Find the basename of the path by looking for the last non-empty segment
+  var filename;
+  var i;
+  for (i = f.length - 1; i >= 0; i--) {
+    filename = f[i];
+    if (filename) break
+  }
+
+  for (i = 0; i < set.length; i++) {
+    var pattern = set[i];
+    var file = f;
+    if (options.matchBase && pattern.length === 1) {
+      file = [filename];
+    }
+    var hit = this.matchOne(file, pattern, partial);
+    if (hit) {
+      if (options.flipNegate) return true
+      return !this.negate
+    }
+  }
+
+  // didn't get any hits.  this is success if it's a negative
+  // pattern, failure otherwise.
+  if (options.flipNegate) return false
+  return this.negate
+}
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+Minimatch$1.prototype.matchOne = function (file, pattern, partial) {
+  var options = this.options;
+
+  this.debug('matchOne',
+    { 'this': this, file: file, pattern: pattern });
+
+  this.debug('matchOne', file.length, pattern.length);
+
+  for (var fi = 0,
+      pi = 0,
+      fl = file.length,
+      pl = pattern.length
+      ; (fi < fl) && (pi < pl)
+      ; fi++, pi++) {
+    this.debug('matchOne loop');
+    var p = pattern[pi];
+    var f = file[fi];
+
+    this.debug(pattern, p, f);
+
+    // should be impossible.
+    // some invalid regexp stuff in the set.
+    if (p === false) return false
+
+    if (p === GLOBSTAR) {
+      this.debug('GLOBSTAR', [pattern, p, f]);
+
+      // "**"
+      // a/**/b/**/c would match the following:
+      // a/b/x/y/z/c
+      // a/x/y/z/b/c
+      // a/b/x/b/x/c
+      // a/b/c
+      // To do this, take the rest of the pattern after
+      // the **, and see if it would match the file remainder.
+      // If so, return success.
+      // If not, the ** "swallows" a segment, and try again.
+      // This is recursively awful.
+      //
+      // a/**/b/**/c matching a/b/x/y/z/c
+      // - a matches a
+      // - doublestar
+      //   - matchOne(b/x/y/z/c, b/**/c)
+      //     - b matches b
+      //     - doublestar
+      //       - matchOne(x/y/z/c, c) -> no
+      //       - matchOne(y/z/c, c) -> no
+      //       - matchOne(z/c, c) -> no
+      //       - matchOne(c, c) yes, hit
+      var fr = fi;
+      var pr = pi + 1;
+      if (pr === pl) {
+        this.debug('** at the end');
+        // a ** at the end will just swallow the rest.
+        // We have found a match.
+        // however, it will not swallow /.x, unless
+        // options.dot is set.
+        // . and .. are *never* matched by **, for explosively
+        // exponential reasons.
+        for (; fi < fl; fi++) {
+          if (file[fi] === '.' || file[fi] === '..' ||
+            (!options.dot && file[fi].charAt(0) === '.')) return false
+        }
+        return true
+      }
+
+      // ok, let's see if we can swallow whatever we can.
+      while (fr < fl) {
+        var swallowee = file[fr];
+
+        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee);
+
+        // XXX remove this slice.  Just pass the start index.
+        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+          this.debug('globstar found match!', fr, fl, swallowee);
+          // found a match.
+          return true
+        } else {
+          // can't swallow "." or ".." ever.
+          // can only swallow ".foo" when explicitly asked.
+          if (swallowee === '.' || swallowee === '..' ||
+            (!options.dot && swallowee.charAt(0) === '.')) {
+            this.debug('dot detected!', file, fr, pattern, pr);
+            break
+          }
+
+          // ** swallows a segment, and continue.
+          this.debug('globstar swallow a segment, and continue');
+          fr++;
+        }
+      }
+
+      // no match was found.
+      // However, in partial mode, we can't say this is necessarily over.
+      // If there's more *pattern* left, then
+      if (partial) {
+        // ran out of file
+        this.debug('\n>>> no match, partial?', file, fr, pattern, pr);
+        if (fr === fl) return true
+      }
+      return false
+    }
+
+    // something other than **
+    // non-magic patterns just have to match exactly
+    // patterns with magic have been turned into regexps.
+    var hit;
+    if (typeof p === 'string') {
+      if (options.nocase) {
+        hit = f.toLowerCase() === p.toLowerCase();
+      } else {
+        hit = f === p;
+      }
+      this.debug('string match', p, f, hit);
+    } else {
+      hit = f.match(p);
+      this.debug('pattern match', p, f, hit);
+    }
+
+    if (!hit) return false
+  }
+
+  // Note: ending in / means that we'll get a final ""
+  // at the end of the pattern.  This can only match a
+  // corresponding "" at the end of the file.
+  // If the file ends in /, then it can only match a
+  // a pattern that ends in /, unless the pattern just
+  // doesn't have any more for it. But, a/b/ should *not*
+  // match "a/b/*", even though "" matches against the
+  // [^/]*? pattern, except in partial mode, where it might
+  // simply not be reached yet.
+  // However, a/b/ should still satisfy a/*
+
+  // now either we fell off the end of the pattern, or we're done.
+  if (fi === fl && pi === pl) {
+    // ran out of pattern and filename at the same time.
+    // an exact hit!
+    return true
+  } else if (fi === fl) {
+    // ran out of file, but still had pattern left.
+    // this is ok if we're doing the match as part of
+    // a glob fs traversal.
+    return partial
+  } else if (pi === pl) {
+    // ran out of pattern, still have file left.
+    // this is only acceptable if we're on the very last
+    // empty segment of a file with a trailing slash.
+    // a/* should match a/b/
+    var emptyFileEnd = (fi === fl - 1) && (file[fi] === '');
+    return emptyFileEnd
+  }
+
+  // should be unreachable.
+  throw new Error('wtf?')
+};
+
+// replace stuff like \* with *
+function globUnescape (s) {
+  return s.replace(/\\(.)/g, '$1')
+}
+
+function regExpEscape (s) {
+  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var inherits_browser = createCommonjsModule(function (module) {
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor;
+    ctor.prototype = Object.create(superCtor.prototype, {
+      constructor: {
+        value: ctor,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    ctor.super_ = superCtor;
+    var TempCtor = function () {};
+    TempCtor.prototype = superCtor.prototype;
+    ctor.prototype = new TempCtor();
+    ctor.prototype.constructor = ctor;
+  };
+}
+});
+
+var inherits$1 = createCommonjsModule(function (module) {
+try {
+  var util$$1 = util;
+  if (typeof util$$1.inherits !== 'function') throw '';
+  module.exports = util$$1.inherits;
+} catch (e) {
+  module.exports = inherits_browser;
+}
+});
+
+function posix(path) {
+	return path.charAt(0) === '/';
+}
+
+function win32(path) {
+	// https://github.com/nodejs/node/blob/b3fcc245fb25539909ef1d5eaa01dbf92e168633/lib/path.js#L56
+	var splitDeviceRe = /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+	var result = splitDeviceRe.exec(path);
+	var device = result[1] || '';
+	var isUnc = Boolean(device && device.charAt(1) !== ':');
+
+	// UNC paths are always absolute
+	return Boolean(result[2] || isUnc);
+}
+
+var index$8 = process.platform === 'win32' ? win32 : posix;
+var posix_1 = posix;
+var win32_1 = win32;
+
+index$8.posix = posix_1;
+index$8.win32 = win32_1;
+
+var alphasort_1 = alphasort$2;
+var alphasorti_1 = alphasorti$2;
+var setopts_1 = setopts$2;
+var ownProp_1 = ownProp$2;
+var makeAbs_1 = makeAbs;
+var finish_1 = finish;
+var mark_1 = mark;
+var isIgnored_1 = isIgnored$2;
+var childrenIgnored_1 = childrenIgnored$2;
+
+function ownProp$2 (obj, field) {
+  return Object.prototype.hasOwnProperty.call(obj, field)
+}
+
+var path$4 = require$$0;
+var minimatch$3 = minimatch_1;
+var isAbsolute$2 = index$8;
+var Minimatch$3 = minimatch$3.Minimatch;
+
+function alphasorti$2 (a, b) {
+  return a.toLowerCase().localeCompare(b.toLowerCase())
+}
+
+function alphasort$2 (a, b) {
+  return a.localeCompare(b)
+}
+
+function setupIgnores (self, options) {
+  self.ignore = options.ignore || [];
+
+  if (!Array.isArray(self.ignore))
+    self.ignore = [self.ignore];
+
+  if (self.ignore.length) {
+    self.ignore = self.ignore.map(ignoreMap);
+  }
+}
+
+// ignore patterns are always in dot:true mode.
+function ignoreMap (pattern) {
+  var gmatcher = null;
+  if (pattern.slice(-3) === '/**') {
+    var gpattern = pattern.replace(/(\/\*\*)+$/, '');
+    gmatcher = new Minimatch$3(gpattern, { dot: true });
+  }
+
+  return {
+    matcher: new Minimatch$3(pattern, { dot: true }),
+    gmatcher: gmatcher
+  }
+}
+
+function setopts$2 (self, pattern, options) {
+  if (!options)
+    options = {};
+
+  // base-matching: just use globstar for that.
+  if (options.matchBase && -1 === pattern.indexOf("/")) {
+    if (options.noglobstar) {
+      throw new Error("base matching requires globstar")
+    }
+    pattern = "**/" + pattern;
+  }
+
+  self.silent = !!options.silent;
+  self.pattern = pattern;
+  self.strict = options.strict !== false;
+  self.realpath = !!options.realpath;
+  self.realpathCache = options.realpathCache || Object.create(null);
+  self.follow = !!options.follow;
+  self.dot = !!options.dot;
+  self.mark = !!options.mark;
+  self.nodir = !!options.nodir;
+  if (self.nodir)
+    self.mark = true;
+  self.sync = !!options.sync;
+  self.nounique = !!options.nounique;
+  self.nonull = !!options.nonull;
+  self.nosort = !!options.nosort;
+  self.nocase = !!options.nocase;
+  self.stat = !!options.stat;
+  self.noprocess = !!options.noprocess;
+  self.absolute = !!options.absolute;
+
+  self.maxLength = options.maxLength || Infinity;
+  self.cache = options.cache || Object.create(null);
+  self.statCache = options.statCache || Object.create(null);
+  self.symlinks = options.symlinks || Object.create(null);
+
+  setupIgnores(self, options);
+
+  self.changedCwd = false;
+  var cwd = process.cwd();
+  if (!ownProp$2(options, "cwd"))
+    self.cwd = cwd;
+  else {
+    self.cwd = path$4.resolve(options.cwd);
+    self.changedCwd = self.cwd !== cwd;
+  }
+
+  self.root = options.root || path$4.resolve(self.cwd, "/");
+  self.root = path$4.resolve(self.root);
+  if (process.platform === "win32")
+    self.root = self.root.replace(/\\/g, "/");
+
+  // TODO: is an absolute `cwd` supposed to be resolved against `root`?
+  // e.g. { cwd: '/test', root: __dirname } === path.join(__dirname, '/test')
+  self.cwdAbs = isAbsolute$2(self.cwd) ? self.cwd : makeAbs(self, self.cwd);
+  if (process.platform === "win32")
+    self.cwdAbs = self.cwdAbs.replace(/\\/g, "/");
+  self.nomount = !!options.nomount;
+
+  // disable comments and negation in Minimatch.
+  // Note that they are not supported in Glob itself anyway.
+  options.nonegate = true;
+  options.nocomment = true;
+
+  self.minimatch = new Minimatch$3(pattern, options);
+  self.options = self.minimatch.options;
+}
+
+function finish (self) {
+  var nou = self.nounique;
+  var all = nou ? [] : Object.create(null);
+
+  for (var i = 0, l = self.matches.length; i < l; i ++) {
+    var matches = self.matches[i];
+    if (!matches || Object.keys(matches).length === 0) {
+      if (self.nonull) {
+        // do like the shell, and spit out the literal glob
+        var literal = self.minimatch.globSet[i];
+        if (nou)
+          all.push(literal);
+        else
+          all[literal] = true;
+      }
+    } else {
+      // had matches
+      var m = Object.keys(matches);
+      if (nou)
+        all.push.apply(all, m);
+      else
+        m.forEach(function (m) {
+          all[m] = true;
+        });
+    }
+  }
+
+  if (!nou)
+    all = Object.keys(all);
+
+  if (!self.nosort)
+    all = all.sort(self.nocase ? alphasorti$2 : alphasort$2);
+
+  // at *some* point we statted all of these
+  if (self.mark) {
+    for (var i = 0; i < all.length; i++) {
+      all[i] = self._mark(all[i]);
+    }
+    if (self.nodir) {
+      all = all.filter(function (e) {
+        var notDir = !(/\/$/.test(e));
+        var c = self.cache[e] || self.cache[makeAbs(self, e)];
+        if (notDir && c)
+          notDir = c !== 'DIR' && !Array.isArray(c);
+        return notDir
+      });
+    }
+  }
+
+  if (self.ignore.length)
+    all = all.filter(function(m) {
+      return !isIgnored$2(self, m)
+    });
+
+  self.found = all;
+}
+
+function mark (self, p) {
+  var abs = makeAbs(self, p);
+  var c = self.cache[abs];
+  var m = p;
+  if (c) {
+    var isDir = c === 'DIR' || Array.isArray(c);
+    var slash = p.slice(-1) === '/';
+
+    if (isDir && !slash)
+      m += '/';
+    else if (!isDir && slash)
+      m = m.slice(0, -1);
+
+    if (m !== p) {
+      var mabs = makeAbs(self, m);
+      self.statCache[mabs] = self.statCache[abs];
+      self.cache[mabs] = self.cache[abs];
+    }
+  }
+
+  return m
+}
+
+// lotta situps...
+function makeAbs (self, f) {
+  var abs = f;
+  if (f.charAt(0) === '/') {
+    abs = path$4.join(self.root, f);
+  } else if (isAbsolute$2(f) || f === '') {
+    abs = f;
+  } else if (self.changedCwd) {
+    abs = path$4.resolve(self.cwd, f);
+  } else {
+    abs = path$4.resolve(f);
+  }
+
+  if (process.platform === 'win32')
+    abs = abs.replace(/\\/g, '/');
+
+  return abs
+}
+
+
+// Return true, if pattern ends with globstar '**', for the accompanying parent directory.
+// Ex:- If node_modules/** is the pattern, add 'node_modules' to ignore list along with it's contents
+function isIgnored$2 (self, path) {
+  if (!self.ignore.length)
+    return false
+
+  return self.ignore.some(function(item) {
+    return item.matcher.match(path) || !!(item.gmatcher && item.gmatcher.match(path))
+  })
+}
+
+function childrenIgnored$2 (self, path) {
+  if (!self.ignore.length)
+    return false
+
+  return self.ignore.some(function(item) {
+    return !!(item.gmatcher && item.gmatcher.match(path))
+  })
+}
+
+var common$2 = {
+	alphasort: alphasort_1,
+	alphasorti: alphasorti_1,
+	setopts: setopts_1,
+	ownProp: ownProp_1,
+	makeAbs: makeAbs_1,
+	finish: finish_1,
+	mark: mark_1,
+	isIgnored: isIgnored_1,
+	childrenIgnored: childrenIgnored_1
+};
+
+var sync = globSync$1;
+globSync$1.GlobSync = GlobSync$1;
+
+var fs$5 = fs;
+var rp$1 = index;
+var minimatch$2 = minimatch_1;
+var path$3 = require$$0;
+var assert$3 = assert;
+var isAbsolute$1 = index$8;
+var common$1 = common$2;
+var setopts$1 = common$1.setopts;
+var ownProp$1 = common$1.ownProp;
+var childrenIgnored$1 = common$1.childrenIgnored;
+var isIgnored$1 = common$1.isIgnored;
+
+function globSync$1 (pattern, options) {
+  if (typeof options === 'function' || arguments.length === 3)
+    throw new TypeError('callback provided to sync glob\n'+
+                        'See: https://github.com/isaacs/node-glob/issues/167')
+
+  return new GlobSync$1(pattern, options).found
+}
+
+function GlobSync$1 (pattern, options) {
+  if (!pattern)
+    throw new Error('must provide pattern')
+
+  if (typeof options === 'function' || arguments.length === 3)
+    throw new TypeError('callback provided to sync glob\n'+
+                        'See: https://github.com/isaacs/node-glob/issues/167')
+
+  if (!(this instanceof GlobSync$1))
+    return new GlobSync$1(pattern, options)
+
+  setopts$1(this, pattern, options);
+
+  if (this.noprocess)
+    return this
+
+  var n = this.minimatch.set.length;
+  this.matches = new Array(n);
+  for (var i = 0; i < n; i ++) {
+    this._process(this.minimatch.set[i], i, false);
+  }
+  this._finish();
+}
+
+GlobSync$1.prototype._finish = function () {
+  assert$3(this instanceof GlobSync$1);
+  if (this.realpath) {
+    var self = this;
+    this.matches.forEach(function (matchset, index$$1) {
+      var set = self.matches[index$$1] = Object.create(null);
+      for (var p in matchset) {
+        try {
+          p = self._makeAbs(p);
+          var real = rp$1.realpathSync(p, self.realpathCache);
+          set[real] = true;
+        } catch (er) {
+          if (er.syscall === 'stat')
+            set[self._makeAbs(p)] = true;
+          else
+            throw er
+        }
+      }
+    });
+  }
+  common$1.finish(this);
+};
+
+
+GlobSync$1.prototype._process = function (pattern, index$$1, inGlobStar) {
+  assert$3(this instanceof GlobSync$1);
+
+  // Get the first [n] parts of pattern that are all strings.
+  var n = 0;
+  while (typeof pattern[n] === 'string') {
+    n ++;
+  }
+  // now n is the index of the first one that is *not* a string.
+
+  // See if there's anything else
+  var prefix;
+  switch (n) {
+    // if not, then this is rather simple
+    case pattern.length:
+      this._processSimple(pattern.join('/'), index$$1);
+      return
+
+    case 0:
+      // pattern *starts* with some non-trivial item.
+      // going to readdir(cwd), but not include the prefix in matches.
+      prefix = null;
+      break
+
+    default:
+      // pattern has some string bits in the front.
+      // whatever it starts with, whether that's 'absolute' like /foo/bar,
+      // or 'relative' like '../baz'
+      prefix = pattern.slice(0, n).join('/');
+      break
+  }
+
+  var remain = pattern.slice(n);
+
+  // get the list of entries.
+  var read;
+  if (prefix === null)
+    read = '.';
+  else if (isAbsolute$1(prefix) || isAbsolute$1(pattern.join('/'))) {
+    if (!prefix || !isAbsolute$1(prefix))
+      prefix = '/' + prefix;
+    read = prefix;
+  } else
+    read = prefix;
+
+  var abs = this._makeAbs(read);
+
+  //if ignored, skip processing
+  if (childrenIgnored$1(this, read))
+    return
+
+  var isGlobStar = remain[0] === minimatch$2.GLOBSTAR;
+  if (isGlobStar)
+    this._processGlobStar(prefix, read, abs, remain, index$$1, inGlobStar);
+  else
+    this._processReaddir(prefix, read, abs, remain, index$$1, inGlobStar);
+};
+
+
+GlobSync$1.prototype._processReaddir = function (prefix, read, abs, remain, index$$1, inGlobStar) {
+  var entries = this._readdir(abs, inGlobStar);
+
+  // if the abs isn't a dir, then nothing can match!
+  if (!entries)
+    return
+
+  // It will only match dot entries if it starts with a dot, or if
+  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
+  var pn = remain[0];
+  var negate = !!this.minimatch.negate;
+  var rawGlob = pn._glob;
+  var dotOk = this.dot || rawGlob.charAt(0) === '.';
+
+  var matchedEntries = [];
+  for (var i = 0; i < entries.length; i++) {
+    var e = entries[i];
+    if (e.charAt(0) !== '.' || dotOk) {
+      var m;
+      if (negate && !prefix) {
+        m = !e.match(pn);
+      } else {
+        m = e.match(pn);
+      }
+      if (m)
+        matchedEntries.push(e);
+    }
+  }
+
+  var len = matchedEntries.length;
+  // If there are no matched entries, then nothing matches.
+  if (len === 0)
+    return
+
+  // if this is the last remaining pattern bit, then no need for
+  // an additional stat *unless* the user has specified mark or
+  // stat explicitly.  We know they exist, since readdir returned
+  // them.
+
+  if (remain.length === 1 && !this.mark && !this.stat) {
+    if (!this.matches[index$$1])
+      this.matches[index$$1] = Object.create(null);
+
+    for (var i = 0; i < len; i ++) {
+      var e = matchedEntries[i];
+      if (prefix) {
+        if (prefix.slice(-1) !== '/')
+          e = prefix + '/' + e;
+        else
+          e = prefix + e;
+      }
+
+      if (e.charAt(0) === '/' && !this.nomount) {
+        e = path$3.join(this.root, e);
+      }
+      this._emitMatch(index$$1, e);
+    }
+    // This was the last one, and no stats were needed
+    return
+  }
+
+  // now test all matched entries as stand-ins for that part
+  // of the pattern.
+  remain.shift();
+  for (var i = 0; i < len; i ++) {
+    var e = matchedEntries[i];
+    var newPattern;
+    if (prefix)
+      newPattern = [prefix, e];
+    else
+      newPattern = [e];
+    this._process(newPattern.concat(remain), index$$1, inGlobStar);
+  }
+};
+
+
+GlobSync$1.prototype._emitMatch = function (index$$1, e) {
+  if (isIgnored$1(this, e))
+    return
+
+  var abs = this._makeAbs(e);
+
+  if (this.mark)
+    e = this._mark(e);
+
+  if (this.absolute) {
+    e = abs;
+  }
+
+  if (this.matches[index$$1][e])
+    return
+
+  if (this.nodir) {
+    var c = this.cache[abs];
+    if (c === 'DIR' || Array.isArray(c))
+      return
+  }
+
+  this.matches[index$$1][e] = true;
+
+  if (this.stat)
+    this._stat(e);
+};
+
+
+GlobSync$1.prototype._readdirInGlobStar = function (abs) {
+  // follow all symlinked directories forever
+  // just proceed as if this is a non-globstar situation
+  if (this.follow)
+    return this._readdir(abs, false)
+
+  var entries;
+  var lstat;
+  var stat;
+  try {
+    lstat = fs$5.lstatSync(abs);
+  } catch (er) {
+    if (er.code === 'ENOENT') {
+      // lstat failed, doesn't exist
+      return null
+    }
+  }
+
+  var isSym = lstat && lstat.isSymbolicLink();
+  this.symlinks[abs] = isSym;
+
+  // If it's not a symlink or a dir, then it's definitely a regular file.
+  // don't bother doing a readdir in that case.
+  if (!isSym && lstat && !lstat.isDirectory())
+    this.cache[abs] = 'FILE';
+  else
+    entries = this._readdir(abs, false);
+
+  return entries
+};
+
+GlobSync$1.prototype._readdir = function (abs, inGlobStar) {
+  var entries;
+
+  if (inGlobStar && !ownProp$1(this.symlinks, abs))
+    return this._readdirInGlobStar(abs)
+
+  if (ownProp$1(this.cache, abs)) {
+    var c = this.cache[abs];
+    if (!c || c === 'FILE')
+      return null
+
+    if (Array.isArray(c))
+      return c
+  }
+
+  try {
+    return this._readdirEntries(abs, fs$5.readdirSync(abs))
+  } catch (er) {
+    this._readdirError(abs, er);
+    return null
+  }
+};
+
+GlobSync$1.prototype._readdirEntries = function (abs, entries) {
+  // if we haven't asked to stat everything, then just
+  // assume that everything in there exists, so we can avoid
+  // having to stat it a second time.
+  if (!this.mark && !this.stat) {
+    for (var i = 0; i < entries.length; i ++) {
+      var e = entries[i];
+      if (abs === '/')
+        e = abs + e;
+      else
+        e = abs + '/' + e;
+      this.cache[e] = true;
+    }
+  }
+
+  this.cache[abs] = entries;
+
+  // mark and cache dir-ness
+  return entries
+};
+
+GlobSync$1.prototype._readdirError = function (f, er) {
+  // handle errors, and cache the information
+  switch (er.code) {
+    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
+    case 'ENOTDIR': // totally normal. means it *does* exist.
+      var abs = this._makeAbs(f);
+      this.cache[abs] = 'FILE';
+      if (abs === this.cwdAbs) {
+        var error = new Error(er.code + ' invalid cwd ' + this.cwd);
+        error.path = this.cwd;
+        error.code = er.code;
+        throw error
+      }
+      break
+
+    case 'ENOENT': // not terribly unusual
+    case 'ELOOP':
+    case 'ENAMETOOLONG':
+    case 'UNKNOWN':
+      this.cache[this._makeAbs(f)] = false;
+      break
+
+    default: // some unusual error.  Treat as failure.
+      this.cache[this._makeAbs(f)] = false;
+      if (this.strict)
+        throw er
+      if (!this.silent)
+        console.error('glob error', er);
+      break
+  }
+};
+
+GlobSync$1.prototype._processGlobStar = function (prefix, read, abs, remain, index$$1, inGlobStar) {
+
+  var entries = this._readdir(abs, inGlobStar);
+
+  // no entries means not a dir, so it can never have matches
+  // foo.txt/** doesn't match foo.txt
+  if (!entries)
+    return
+
+  // test without the globstar, and with every child both below
+  // and replacing the globstar.
+  var remainWithoutGlobStar = remain.slice(1);
+  var gspref = prefix ? [ prefix ] : [];
+  var noGlobStar = gspref.concat(remainWithoutGlobStar);
+
+  // the noGlobStar pattern exits the inGlobStar state
+  this._process(noGlobStar, index$$1, false);
+
+  var len = entries.length;
+  var isSym = this.symlinks[abs];
+
+  // If it's a symlink, and we're in a globstar, then stop
+  if (isSym && inGlobStar)
+    return
+
+  for (var i = 0; i < len; i++) {
+    var e = entries[i];
+    if (e.charAt(0) === '.' && !this.dot)
+      continue
+
+    // these two cases enter the inGlobStar state
+    var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+    this._process(instead, index$$1, true);
+
+    var below = gspref.concat(entries[i], remain);
+    this._process(below, index$$1, true);
+  }
+};
+
+GlobSync$1.prototype._processSimple = function (prefix, index$$1) {
+  // XXX review this.  Shouldn't it be doing the mounting etc
+  // before doing stat?  kinda weird?
+  var exists = this._stat(prefix);
+
+  if (!this.matches[index$$1])
+    this.matches[index$$1] = Object.create(null);
+
+  // If it doesn't exist, then just mark the lack of results
+  if (!exists)
+    return
+
+  if (prefix && isAbsolute$1(prefix) && !this.nomount) {
+    var trail = /[\/\\]$/.test(prefix);
+    if (prefix.charAt(0) === '/') {
+      prefix = path$3.join(this.root, prefix);
+    } else {
+      prefix = path$3.resolve(this.root, prefix);
+      if (trail)
+        prefix += '/';
+    }
+  }
+
+  if (process.platform === 'win32')
+    prefix = prefix.replace(/\\/g, '/');
+
+  // Mark this as a match
+  this._emitMatch(index$$1, prefix);
+};
+
+// Returns either 'DIR', 'FILE', or false
+GlobSync$1.prototype._stat = function (f) {
+  var abs = this._makeAbs(f);
+  var needDir = f.slice(-1) === '/';
+
+  if (f.length > this.maxLength)
+    return false
+
+  if (!this.stat && ownProp$1(this.cache, abs)) {
+    var c = this.cache[abs];
+
+    if (Array.isArray(c))
+      c = 'DIR';
+
+    // It exists, but maybe not how we need it
+    if (!needDir || c === 'DIR')
+      return c
+
+    if (needDir && c === 'FILE')
+      return false
+
+    // otherwise we have to stat, because maybe c=true
+    // if we know it exists, but not what it is.
+  }
+
+  var exists;
+  var stat = this.statCache[abs];
+  if (!stat) {
+    var lstat;
+    try {
+      lstat = fs$5.lstatSync(abs);
+    } catch (er) {
+      if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+        this.statCache[abs] = false;
+        return false
+      }
+    }
+
+    if (lstat && lstat.isSymbolicLink()) {
+      try {
+        stat = fs$5.statSync(abs);
+      } catch (er) {
+        stat = lstat;
+      }
+    } else {
+      stat = lstat;
+    }
+  }
+
+  this.statCache[abs] = stat;
+
+  var c = true;
+  if (stat)
+    c = stat.isDirectory() ? 'DIR' : 'FILE';
+
+  this.cache[abs] = this.cache[abs] || c;
+
+  if (needDir && c === 'FILE')
+    return false
+
+  return c
+};
+
+GlobSync$1.prototype._mark = function (p) {
+  return common$1.mark(this, p)
+};
+
+GlobSync$1.prototype._makeAbs = function (f) {
+  return common$1.makeAbs(this, f)
+};
+
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+var wrappy_1 = wrappy$1;
+function wrappy$1 (fn, cb) {
+  if (fn && cb) return wrappy$1(fn)(cb)
+
+  if (typeof fn !== 'function')
+    throw new TypeError('need wrapper function')
+
+  Object.keys(fn).forEach(function (k) {
+    wrapper[k] = fn[k];
+  });
+
+  return wrapper
+
+  function wrapper() {
+    var args = new Array(arguments.length);
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i];
+    }
+    var ret = fn.apply(this, args);
+    var cb = args[args.length-1];
+    if (typeof ret === 'function' && ret !== cb) {
+      Object.keys(cb).forEach(function (k) {
+        ret[k] = cb[k];
+      });
+    }
+    return ret
+  }
+}
+
+var wrappy$2 = wrappy_1;
+var once_1 = wrappy$2(once$2);
+var strict = wrappy$2(onceStrict);
+
+once$2.proto = once$2(function () {
+  Object.defineProperty(Function.prototype, 'once', {
+    value: function () {
+      return once$2(this)
+    },
+    configurable: true
+  });
+
+  Object.defineProperty(Function.prototype, 'onceStrict', {
+    value: function () {
+      return onceStrict(this)
+    },
+    configurable: true
+  });
+});
+
+function once$2 (fn) {
+  var f = function () {
+    if (f.called) return f.value
+    f.called = true;
+    return f.value = fn.apply(this, arguments)
+  };
+  f.called = false;
+  return f
+}
+
+function onceStrict (fn) {
+  var f = function () {
+    if (f.called)
+      throw new Error(f.onceError)
+    f.called = true;
+    return f.value = fn.apply(this, arguments)
+  };
+  var name = fn.name || 'Function wrapped with `once`';
+  f.onceError = name + " shouldn't be called more than once";
+  f.called = false;
+  return f
+}
+
+once_1.strict = strict;
+
+var wrappy = wrappy_1;
+var reqs = Object.create(null);
+var once$1 = once_1;
+
+var inflight_1 = wrappy(inflight$1);
+
+function inflight$1 (key, cb) {
+  if (reqs[key]) {
+    reqs[key].push(cb);
+    return null
+  } else {
+    reqs[key] = [cb];
+    return makeres(key)
+  }
+}
+
+function makeres (key) {
+  return once$1(function RES () {
+    var cbs = reqs[key];
+    var len = cbs.length;
+    var args = slice(arguments);
+
+    // XXX It's somewhat ambiguous whether a new callback added in this
+    // pass should be queued for later execution if something in the
+    // list of callbacks throws, or if it should just be discarded.
+    // However, it's such an edge case that it hardly matters, and either
+    // choice is likely as surprising as the other.
+    // As it happens, we do go ahead and schedule it for later execution.
+    try {
+      for (var i = 0; i < len; i++) {
+        cbs[i].apply(null, args);
+      }
+    } finally {
+      if (cbs.length > len) {
+        // added more in the interim.
+        // de-zalgo, just in case, but don't call again.
+        cbs.splice(0, len);
+        process.nextTick(function () {
+          RES.apply(null, args);
+        });
+      } else {
+        delete reqs[key];
+      }
+    }
+  })
+}
+
+function slice (args) {
+  var length = args.length;
+  var array = [];
+
+  for (var i = 0; i < length; i++) array[i] = args[i];
+  return array
+}
+
+// Approach:
+//
+// 1. Get the minimatch set
+// 2. For each pattern in the set, PROCESS(pattern, false)
+// 3. Store matches per-set, then uniq them
+//
+// PROCESS(pattern, inGlobStar)
+// Get the first [n] items from pattern that are all strings
+// Join these together.  This is PREFIX.
+//   If there is no more remaining, then stat(PREFIX) and
+//   add to matches if it succeeds.  END.
+//
+// If inGlobStar and PREFIX is symlink and points to dir
+//   set ENTRIES = []
+// else readdir(PREFIX) as ENTRIES
+//   If fail, END
+//
+// with ENTRIES
+//   If pattern[n] is GLOBSTAR
+//     // handle the case where the globstar match is empty
+//     // by pruning it out, and testing the resulting pattern
+//     PROCESS(pattern[0..n] + pattern[n+1 .. $], false)
+//     // handle other cases.
+//     for ENTRY in ENTRIES (not dotfiles)
+//       // attach globstar + tail onto the entry
+//       // Mark that this entry is a globstar match
+//       PROCESS(pattern[0..n] + ENTRY + pattern[n .. $], true)
+//
+//   else // not globstar
+//     for ENTRY in ENTRIES (not dotfiles, unless pattern[n] is dot)
+//       Test ENTRY against pattern[n]
+//       If fails, continue
+//       If passes, PROCESS(pattern[0..n] + item + pattern[n+1 .. $])
+//
+// Caveat:
+//   Cache all stats and readdirs results to minimize syscall.  Since all
+//   we ever care about is existence and directory-ness, we can just keep
+//   `true` for files, and [children,...] for directories, or `false` for
+//   things that don't exist.
+
+var glob_1 = glob$1;
+
+var fs$2 = fs;
+var rp = index;
+var minimatch = minimatch_1;
+var inherits = inherits$1;
+var EE = events.EventEmitter;
+var path$1 = require$$0;
+var assert$2 = assert;
+var isAbsolute = index$8;
+var globSync = sync;
+var common = common$2;
+var setopts = common.setopts;
+var ownProp = common.ownProp;
+var inflight = inflight_1;
+var childrenIgnored = common.childrenIgnored;
+var isIgnored = common.isIgnored;
+
+var once = once_1;
+
+function glob$1 (pattern, options, cb) {
+  if (typeof options === 'function') cb = options, options = {};
+  if (!options) options = {};
+
+  if (options.sync) {
+    if (cb)
+      throw new TypeError('callback provided to sync glob')
+    return globSync(pattern, options)
+  }
+
+  return new Glob(pattern, options, cb)
+}
+
+glob$1.sync = globSync;
+var GlobSync = glob$1.GlobSync = globSync.GlobSync;
+
+// old api surface
+glob$1.glob = glob$1;
+
+function extend (origin, add) {
+  if (add === null || typeof add !== 'object') {
+    return origin
+  }
+
+  var keys = Object.keys(add);
+  var i = keys.length;
+  while (i--) {
+    origin[keys[i]] = add[keys[i]];
+  }
+  return origin
+}
+
+glob$1.hasMagic = function (pattern, options_) {
+  var options = extend({}, options_);
+  options.noprocess = true;
+
+  var g = new Glob(pattern, options);
+  var set = g.minimatch.set;
+
+  if (!pattern)
+    return false
+
+  if (set.length > 1)
+    return true
+
+  for (var j = 0; j < set[0].length; j++) {
+    if (typeof set[0][j] !== 'string')
+      return true
+  }
+
+  return false
+};
+
+glob$1.Glob = Glob;
+inherits(Glob, EE);
+function Glob (pattern, options, cb) {
+  if (typeof options === 'function') {
+    cb = options;
+    options = null;
+  }
+
+  if (options && options.sync) {
+    if (cb)
+      throw new TypeError('callback provided to sync glob')
+    return new GlobSync(pattern, options)
+  }
+
+  if (!(this instanceof Glob))
+    return new Glob(pattern, options, cb)
+
+  setopts(this, pattern, options);
+  this._didRealPath = false;
+
+  // process each pattern in the minimatch set
+  var n = this.minimatch.set.length;
+
+  // The matches are stored as {<filename>: true,...} so that
+  // duplicates are automagically pruned.
+  // Later, we do an Object.keys() on these.
+  // Keep them as a list so we can fill in when nonull is set.
+  this.matches = new Array(n);
+
+  if (typeof cb === 'function') {
+    cb = once(cb);
+    this.on('error', cb);
+    this.on('end', function (matches) {
+      cb(null, matches);
+    });
+  }
+
+  var self = this;
+  var n = this.minimatch.set.length;
+  this._processing = 0;
+  this.matches = new Array(n);
+
+  this._emitQueue = [];
+  this._processQueue = [];
+  this.paused = false;
+
+  if (this.noprocess)
+    return this
+
+  if (n === 0)
+    return done()
+
+  var sync$$1 = true;
+  for (var i = 0; i < n; i ++) {
+    this._process(this.minimatch.set[i], i, false, done);
+  }
+  sync$$1 = false;
+
+  function done () {
+    --self._processing;
+    if (self._processing <= 0) {
+      if (sync$$1) {
+        process.nextTick(function () {
+          self._finish();
+        });
+      } else {
+        self._finish();
+      }
+    }
+  }
+}
+
+Glob.prototype._finish = function () {
+  assert$2(this instanceof Glob);
+  if (this.aborted)
+    return
+
+  if (this.realpath && !this._didRealpath)
+    return this._realpath()
+
+  common.finish(this);
+  this.emit('end', this.found);
+};
+
+Glob.prototype._realpath = function () {
+  if (this._didRealpath)
+    return
+
+  this._didRealpath = true;
+
+  var n = this.matches.length;
+  if (n === 0)
+    return this._finish()
+
+  var self = this;
+  for (var i = 0; i < this.matches.length; i++)
+    this._realpathSet(i, next);
+
+  function next () {
+    if (--n === 0)
+      self._finish();
+  }
+};
+
+Glob.prototype._realpathSet = function (index$$1, cb) {
+  var matchset = this.matches[index$$1];
+  if (!matchset)
+    return cb()
+
+  var found = Object.keys(matchset);
+  var self = this;
+  var n = found.length;
+
+  if (n === 0)
+    return cb()
+
+  var set = this.matches[index$$1] = Object.create(null);
+  found.forEach(function (p, i) {
+    // If there's a problem with the stat, then it means that
+    // one or more of the links in the realpath couldn't be
+    // resolved.  just return the abs value in that case.
+    p = self._makeAbs(p);
+    rp.realpath(p, self.realpathCache, function (er, real) {
+      if (!er)
+        set[real] = true;
+      else if (er.syscall === 'stat')
+        set[p] = true;
+      else
+        self.emit('error', er); // srsly wtf right here
+
+      if (--n === 0) {
+        self.matches[index$$1] = set;
+        cb();
+      }
+    });
+  });
+};
+
+Glob.prototype._mark = function (p) {
+  return common.mark(this, p)
+};
+
+Glob.prototype._makeAbs = function (f) {
+  return common.makeAbs(this, f)
+};
+
+Glob.prototype.abort = function () {
+  this.aborted = true;
+  this.emit('abort');
+};
+
+Glob.prototype.pause = function () {
+  if (!this.paused) {
+    this.paused = true;
+    this.emit('pause');
+  }
+};
+
+Glob.prototype.resume = function () {
+  if (this.paused) {
+    this.emit('resume');
+    this.paused = false;
+    if (this._emitQueue.length) {
+      var eq = this._emitQueue.slice(0);
+      this._emitQueue.length = 0;
+      for (var i = 0; i < eq.length; i ++) {
+        var e = eq[i];
+        this._emitMatch(e[0], e[1]);
+      }
+    }
+    if (this._processQueue.length) {
+      var pq = this._processQueue.slice(0);
+      this._processQueue.length = 0;
+      for (var i = 0; i < pq.length; i ++) {
+        var p = pq[i];
+        this._processing--;
+        this._process(p[0], p[1], p[2], p[3]);
+      }
+    }
+  }
+};
+
+Glob.prototype._process = function (pattern, index$$1, inGlobStar, cb) {
+  assert$2(this instanceof Glob);
+  assert$2(typeof cb === 'function');
+
+  if (this.aborted)
+    return
+
+  this._processing++;
+  if (this.paused) {
+    this._processQueue.push([pattern, index$$1, inGlobStar, cb]);
+    return
+  }
+
+  //console.error('PROCESS %d', this._processing, pattern)
+
+  // Get the first [n] parts of pattern that are all strings.
+  var n = 0;
+  while (typeof pattern[n] === 'string') {
+    n ++;
+  }
+  // now n is the index of the first one that is *not* a string.
+
+  // see if there's anything else
+  var prefix;
+  switch (n) {
+    // if not, then this is rather simple
+    case pattern.length:
+      this._processSimple(pattern.join('/'), index$$1, cb);
+      return
+
+    case 0:
+      // pattern *starts* with some non-trivial item.
+      // going to readdir(cwd), but not include the prefix in matches.
+      prefix = null;
+      break
+
+    default:
+      // pattern has some string bits in the front.
+      // whatever it starts with, whether that's 'absolute' like /foo/bar,
+      // or 'relative' like '../baz'
+      prefix = pattern.slice(0, n).join('/');
+      break
+  }
+
+  var remain = pattern.slice(n);
+
+  // get the list of entries.
+  var read;
+  if (prefix === null)
+    read = '.';
+  else if (isAbsolute(prefix) || isAbsolute(pattern.join('/'))) {
+    if (!prefix || !isAbsolute(prefix))
+      prefix = '/' + prefix;
+    read = prefix;
+  } else
+    read = prefix;
+
+  var abs = this._makeAbs(read);
+
+  //if ignored, skip _processing
+  if (childrenIgnored(this, read))
+    return cb()
+
+  var isGlobStar = remain[0] === minimatch.GLOBSTAR;
+  if (isGlobStar)
+    this._processGlobStar(prefix, read, abs, remain, index$$1, inGlobStar, cb);
+  else
+    this._processReaddir(prefix, read, abs, remain, index$$1, inGlobStar, cb);
+};
+
+Glob.prototype._processReaddir = function (prefix, read, abs, remain, index$$1, inGlobStar, cb) {
+  var self = this;
+  this._readdir(abs, inGlobStar, function (er, entries) {
+    return self._processReaddir2(prefix, read, abs, remain, index$$1, inGlobStar, entries, cb)
+  });
+};
+
+Glob.prototype._processReaddir2 = function (prefix, read, abs, remain, index$$1, inGlobStar, entries, cb) {
+
+  // if the abs isn't a dir, then nothing can match!
+  if (!entries)
+    return cb()
+
+  // It will only match dot entries if it starts with a dot, or if
+  // dot is set.  Stuff like @(.foo|.bar) isn't allowed.
+  var pn = remain[0];
+  var negate = !!this.minimatch.negate;
+  var rawGlob = pn._glob;
+  var dotOk = this.dot || rawGlob.charAt(0) === '.';
+
+  var matchedEntries = [];
+  for (var i = 0; i < entries.length; i++) {
+    var e = entries[i];
+    if (e.charAt(0) !== '.' || dotOk) {
+      var m;
+      if (negate && !prefix) {
+        m = !e.match(pn);
+      } else {
+        m = e.match(pn);
+      }
+      if (m)
+        matchedEntries.push(e);
+    }
+  }
+
+  //console.error('prd2', prefix, entries, remain[0]._glob, matchedEntries)
+
+  var len = matchedEntries.length;
+  // If there are no matched entries, then nothing matches.
+  if (len === 0)
+    return cb()
+
+  // if this is the last remaining pattern bit, then no need for
+  // an additional stat *unless* the user has specified mark or
+  // stat explicitly.  We know they exist, since readdir returned
+  // them.
+
+  if (remain.length === 1 && !this.mark && !this.stat) {
+    if (!this.matches[index$$1])
+      this.matches[index$$1] = Object.create(null);
+
+    for (var i = 0; i < len; i ++) {
+      var e = matchedEntries[i];
+      if (prefix) {
+        if (prefix !== '/')
+          e = prefix + '/' + e;
+        else
+          e = prefix + e;
+      }
+
+      if (e.charAt(0) === '/' && !this.nomount) {
+        e = path$1.join(this.root, e);
+      }
+      this._emitMatch(index$$1, e);
+    }
+    // This was the last one, and no stats were needed
+    return cb()
+  }
+
+  // now test all matched entries as stand-ins for that part
+  // of the pattern.
+  remain.shift();
+  for (var i = 0; i < len; i ++) {
+    var e = matchedEntries[i];
+    var newPattern;
+    if (prefix) {
+      if (prefix !== '/')
+        e = prefix + '/' + e;
+      else
+        e = prefix + e;
+    }
+    this._process([e].concat(remain), index$$1, inGlobStar, cb);
+  }
+  cb();
+};
+
+Glob.prototype._emitMatch = function (index$$1, e) {
+  if (this.aborted)
+    return
+
+  if (isIgnored(this, e))
+    return
+
+  if (this.paused) {
+    this._emitQueue.push([index$$1, e]);
+    return
+  }
+
+  var abs = isAbsolute(e) ? e : this._makeAbs(e);
+
+  if (this.mark)
+    e = this._mark(e);
+
+  if (this.absolute)
+    e = abs;
+
+  if (this.matches[index$$1][e])
+    return
+
+  if (this.nodir) {
+    var c = this.cache[abs];
+    if (c === 'DIR' || Array.isArray(c))
+      return
+  }
+
+  this.matches[index$$1][e] = true;
+
+  var st = this.statCache[abs];
+  if (st)
+    this.emit('stat', e, st);
+
+  this.emit('match', e);
+};
+
+Glob.prototype._readdirInGlobStar = function (abs, cb) {
+  if (this.aborted)
+    return
+
+  // follow all symlinked directories forever
+  // just proceed as if this is a non-globstar situation
+  if (this.follow)
+    return this._readdir(abs, false, cb)
+
+  var lstatkey = 'lstat\0' + abs;
+  var self = this;
+  var lstatcb = inflight(lstatkey, lstatcb_);
+
+  if (lstatcb)
+    fs$2.lstat(abs, lstatcb);
+
+  function lstatcb_ (er, lstat) {
+    if (er && er.code === 'ENOENT')
+      return cb()
+
+    var isSym = lstat && lstat.isSymbolicLink();
+    self.symlinks[abs] = isSym;
+
+    // If it's not a symlink or a dir, then it's definitely a regular file.
+    // don't bother doing a readdir in that case.
+    if (!isSym && lstat && !lstat.isDirectory()) {
+      self.cache[abs] = 'FILE';
+      cb();
+    } else
+      self._readdir(abs, false, cb);
+  }
+};
+
+Glob.prototype._readdir = function (abs, inGlobStar, cb) {
+  if (this.aborted)
+    return
+
+  cb = inflight('readdir\0'+abs+'\0'+inGlobStar, cb);
+  if (!cb)
+    return
+
+  //console.error('RD %j %j', +inGlobStar, abs)
+  if (inGlobStar && !ownProp(this.symlinks, abs))
+    return this._readdirInGlobStar(abs, cb)
+
+  if (ownProp(this.cache, abs)) {
+    var c = this.cache[abs];
+    if (!c || c === 'FILE')
+      return cb()
+
+    if (Array.isArray(c))
+      return cb(null, c)
+  }
+
+  var self = this;
+  fs$2.readdir(abs, readdirCb(this, abs, cb));
+};
+
+function readdirCb (self, abs, cb) {
+  return function (er, entries) {
+    if (er)
+      self._readdirError(abs, er, cb);
+    else
+      self._readdirEntries(abs, entries, cb);
+  }
+}
+
+Glob.prototype._readdirEntries = function (abs, entries, cb) {
+  if (this.aborted)
+    return
+
+  // if we haven't asked to stat everything, then just
+  // assume that everything in there exists, so we can avoid
+  // having to stat it a second time.
+  if (!this.mark && !this.stat) {
+    for (var i = 0; i < entries.length; i ++) {
+      var e = entries[i];
+      if (abs === '/')
+        e = abs + e;
+      else
+        e = abs + '/' + e;
+      this.cache[e] = true;
+    }
+  }
+
+  this.cache[abs] = entries;
+  return cb(null, entries)
+};
+
+Glob.prototype._readdirError = function (f, er, cb) {
+  if (this.aborted)
+    return
+
+  // handle errors, and cache the information
+  switch (er.code) {
+    case 'ENOTSUP': // https://github.com/isaacs/node-glob/issues/205
+    case 'ENOTDIR': // totally normal. means it *does* exist.
+      var abs = this._makeAbs(f);
+      this.cache[abs] = 'FILE';
+      if (abs === this.cwdAbs) {
+        var error = new Error(er.code + ' invalid cwd ' + this.cwd);
+        error.path = this.cwd;
+        error.code = er.code;
+        this.emit('error', error);
+        this.abort();
+      }
+      break
+
+    case 'ENOENT': // not terribly unusual
+    case 'ELOOP':
+    case 'ENAMETOOLONG':
+    case 'UNKNOWN':
+      this.cache[this._makeAbs(f)] = false;
+      break
+
+    default: // some unusual error.  Treat as failure.
+      this.cache[this._makeAbs(f)] = false;
+      if (this.strict) {
+        this.emit('error', er);
+        // If the error is handled, then we abort
+        // if not, we threw out of here
+        this.abort();
+      }
+      if (!this.silent)
+        console.error('glob error', er);
+      break
+  }
+
+  return cb()
+};
+
+Glob.prototype._processGlobStar = function (prefix, read, abs, remain, index$$1, inGlobStar, cb) {
+  var self = this;
+  this._readdir(abs, inGlobStar, function (er, entries) {
+    self._processGlobStar2(prefix, read, abs, remain, index$$1, inGlobStar, entries, cb);
+  });
+};
+
+
+Glob.prototype._processGlobStar2 = function (prefix, read, abs, remain, index$$1, inGlobStar, entries, cb) {
+  //console.error('pgs2', prefix, remain[0], entries)
+
+  // no entries means not a dir, so it can never have matches
+  // foo.txt/** doesn't match foo.txt
+  if (!entries)
+    return cb()
+
+  // test without the globstar, and with every child both below
+  // and replacing the globstar.
+  var remainWithoutGlobStar = remain.slice(1);
+  var gspref = prefix ? [ prefix ] : [];
+  var noGlobStar = gspref.concat(remainWithoutGlobStar);
+
+  // the noGlobStar pattern exits the inGlobStar state
+  this._process(noGlobStar, index$$1, false, cb);
+
+  var isSym = this.symlinks[abs];
+  var len = entries.length;
+
+  // If it's a symlink, and we're in a globstar, then stop
+  if (isSym && inGlobStar)
+    return cb()
+
+  for (var i = 0; i < len; i++) {
+    var e = entries[i];
+    if (e.charAt(0) === '.' && !this.dot)
+      continue
+
+    // these two cases enter the inGlobStar state
+    var instead = gspref.concat(entries[i], remainWithoutGlobStar);
+    this._process(instead, index$$1, true, cb);
+
+    var below = gspref.concat(entries[i], remain);
+    this._process(below, index$$1, true, cb);
+  }
+
+  cb();
+};
+
+Glob.prototype._processSimple = function (prefix, index$$1, cb) {
+  // XXX review this.  Shouldn't it be doing the mounting etc
+  // before doing stat?  kinda weird?
+  var self = this;
+  this._stat(prefix, function (er, exists) {
+    self._processSimple2(prefix, index$$1, er, exists, cb);
+  });
+};
+Glob.prototype._processSimple2 = function (prefix, index$$1, er, exists, cb) {
+
+  //console.error('ps2', prefix, exists)
+
+  if (!this.matches[index$$1])
+    this.matches[index$$1] = Object.create(null);
+
+  // If it doesn't exist, then just mark the lack of results
+  if (!exists)
+    return cb()
+
+  if (prefix && isAbsolute(prefix) && !this.nomount) {
+    var trail = /[\/\\]$/.test(prefix);
+    if (prefix.charAt(0) === '/') {
+      prefix = path$1.join(this.root, prefix);
+    } else {
+      prefix = path$1.resolve(this.root, prefix);
+      if (trail)
+        prefix += '/';
+    }
+  }
+
+  if (process.platform === 'win32')
+    prefix = prefix.replace(/\\/g, '/');
+
+  // Mark this as a match
+  this._emitMatch(index$$1, prefix);
+  cb();
+};
+
+// Returns either 'DIR', 'FILE', or false
+Glob.prototype._stat = function (f, cb) {
+  var abs = this._makeAbs(f);
+  var needDir = f.slice(-1) === '/';
+
+  if (f.length > this.maxLength)
+    return cb()
+
+  if (!this.stat && ownProp(this.cache, abs)) {
+    var c = this.cache[abs];
+
+    if (Array.isArray(c))
+      c = 'DIR';
+
+    // It exists, but maybe not how we need it
+    if (!needDir || c === 'DIR')
+      return cb(null, c)
+
+    if (needDir && c === 'FILE')
+      return cb()
+
+    // otherwise we have to stat, because maybe c=true
+    // if we know it exists, but not what it is.
+  }
+
+  var exists;
+  var stat = this.statCache[abs];
+  if (stat !== undefined) {
+    if (stat === false)
+      return cb(null, stat)
+    else {
+      var type = stat.isDirectory() ? 'DIR' : 'FILE';
+      if (needDir && type === 'FILE')
+        return cb()
+      else
+        return cb(null, type, stat)
+    }
+  }
+
+  var self = this;
+  var statcb = inflight('stat\0' + abs, lstatcb_);
+  if (statcb)
+    fs$2.lstat(abs, statcb);
+
+  function lstatcb_ (er, lstat) {
+    if (lstat && lstat.isSymbolicLink()) {
+      // If it's a symlink, then treat it as the target, unless
+      // the target does not exist, then treat it as a file.
+      return fs$2.stat(abs, function (er, stat) {
+        if (er)
+          self._stat2(f, abs, null, lstat, cb);
+        else
+          self._stat2(f, abs, er, stat, cb);
+      })
+    } else {
+      self._stat2(f, abs, er, lstat, cb);
+    }
+  }
+};
+
+Glob.prototype._stat2 = function (f, abs, er, stat, cb) {
+  if (er && (er.code === 'ENOENT' || er.code === 'ENOTDIR')) {
+    this.statCache[abs] = false;
+    return cb()
+  }
+
+  var needDir = f.slice(-1) === '/';
+  this.statCache[abs] = stat;
+
+  if (abs.slice(-1) === '/' && stat && !stat.isDirectory())
+    return cb(null, false, stat)
+
+  var c = true;
+  if (stat)
+    c = stat.isDirectory() ? 'DIR' : 'FILE';
+  this.cache[abs] = this.cache[abs] || c;
+
+  if (needDir && c === 'FILE')
+    return cb()
+
+  return cb(null, c, stat)
+};
+
+var rimraf_1 = rimraf$1;
+rimraf$1.sync = rimrafSync;
+
+var assert$1 = assert;
+var path = require$$0;
+var fs$1 = fs;
+var glob = glob_1;
+
+var defaultGlobOpts = {
+  nosort: true,
+  silent: true
+};
+
+// for EMFILE handling
+var timeout = 0;
+
+var isWindows = (process.platform === "win32");
+
+function defaults (options) {
+  var methods = [
+    'unlink',
+    'chmod',
+    'stat',
+    'lstat',
+    'rmdir',
+    'readdir'
+  ];
+  methods.forEach(function(m) {
+    options[m] = options[m] || fs$1[m];
+    m = m + 'Sync';
+    options[m] = options[m] || fs$1[m];
+  });
+
+  options.maxBusyTries = options.maxBusyTries || 3;
+  options.emfileWait = options.emfileWait || 1000;
+  if (options.glob === false) {
+    options.disableGlob = true;
+  }
+  options.disableGlob = options.disableGlob || false;
+  options.glob = options.glob || defaultGlobOpts;
+}
+
+function rimraf$1 (p, options, cb) {
+  if (typeof options === 'function') {
+    cb = options;
+    options = {};
+  }
+
+  assert$1(p, 'rimraf: missing path');
+  assert$1.equal(typeof p, 'string', 'rimraf: path should be a string');
+  assert$1.equal(typeof cb, 'function', 'rimraf: callback function required');
+  assert$1(options, 'rimraf: invalid options argument provided');
+  assert$1.equal(typeof options, 'object', 'rimraf: options should be object');
+
+  defaults(options);
+
+  var busyTries = 0;
+  var errState = null;
+  var n = 0;
+
+  if (options.disableGlob || !glob.hasMagic(p))
+    return afterGlob(null, [p])
+
+  options.lstat(p, function (er, stat) {
+    if (!er)
+      return afterGlob(null, [p])
+
+    glob(p, options.glob, afterGlob);
+  });
+
+  function next (er) {
+    errState = errState || er;
+    if (--n === 0)
+      cb(errState);
+  }
+
+  function afterGlob (er, results) {
+    if (er)
+      return cb(er)
+
+    n = results.length;
+    if (n === 0)
+      return cb()
+
+    results.forEach(function (p) {
+      rimraf_(p, options, function CB (er) {
+        if (er) {
+          if ((er.code === "EBUSY" || er.code === "ENOTEMPTY" || er.code === "EPERM") &&
+              busyTries < options.maxBusyTries) {
+            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 < options.emfileWait) {
+            return setTimeout(function () {
+              rimraf_(p, options, CB);
+            }, timeout ++)
+          }
+
+          // already gone
+          if (er.code === "ENOENT") er = null;
+        }
+
+        timeout = 0;
+        next(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$1(p);
+  assert$1(options);
+  assert$1(typeof cb === 'function');
+
+  // sunos lets the root user unlink directories, which is... weird.
+  // so we have to lstat here and make sure it's not a dir.
+  options.lstat(p, function (er, st) {
+    if (er && er.code === "ENOENT")
+      return cb(null)
+
+    // Windows can EPERM on stat.  Life is suffering.
+    if (er && er.code === "EPERM" && isWindows)
+      fixWinEPERM(p, options, er, cb);
+
+    if (st && st.isDirectory())
+      return rmdir(p, options, er, cb)
+
+    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$1(p);
+  assert$1(options);
+  assert$1(typeof cb === 'function');
+  if (er)
+    assert$1(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$1(p);
+  assert$1(options);
+  if (er)
+    assert$1(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$1(p);
+  assert$1(options);
+  if (originalEr)
+    assert$1(originalEr instanceof Error);
+  assert$1(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$1(p);
+  assert$1(options);
+  assert$1(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$1(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$1(p, 'rimraf: missing path');
+  assert$1.equal(typeof p, 'string', 'rimraf: path should be a string');
+  assert$1(options, 'rimraf: missing options');
+  assert$1.equal(typeof options, 'object', 'rimraf: options should be object');
+
+  var results;
+
+  if (options.disableGlob || !glob.hasMagic(p)) {
+    results = [p];
+  } else {
+    try {
+      options.lstatSync(p);
+      results = [p];
+    } catch (er) {
+      results = glob.sync(p, options.glob);
+    }
+  }
+
+  if (!results.length)
+    return
+
+  for (var i = 0; i < results.length; i++) {
+    var p = results[i];
+
+    try {
+      var st = options.lstatSync(p);
+    } catch (er) {
+      if (er.code === "ENOENT")
+        return
+
+      // Windows can EPERM on stat.  Life is suffering.
+      if (er.code === "EPERM" && isWindows)
+        fixWinEPERMSync(p, options, er);
+    }
+
+    try {
+      // sunos lets the root user unlink directories, which is... weird.
+      if (st && st.isDirectory())
+        rmdirSync(p, options, null);
+      else
+        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$1(p);
+  assert$1(options);
+  if (originalEr)
+    assert$1(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$1(p);
+  assert$1(options);
+  options.readdirSync(p).forEach(function (f) {
+    rimrafSync(path.join(p, f), options);
+  });
+
+  // We only end up here once we got ENOTEMPTY at least once, and
+  // at this point, we are guaranteed to have removed all the kids.
+  // So, we know that it won't be ENOENT or ENOTDIR or anything else.
+  // try really hard to delete stuff on windows, because it has a
+  // PROFOUNDLY annoying habit of not closing handles promptly when
+  // files are deleted, resulting in spurious ENOTEMPTY errors.
+  var retries = isWindows ? 100 : 1;
+  var i = 0;
+  do {
+    var threw = true;
+    try {
+      var ret = options.rmdirSync(p, options);
+      threw = false;
+      return ret
+    } finally {
+      if (++i < retries && threw)
+        continue
+    }
+  } while (true)
+}
+
+//removed node
+
+var rimraf = rimraf_1;
+
+var help = false;
+var dashdash = false;
+var noglob = false;
+var args = process.argv.slice(2).filter(function(arg) {
+  if (dashdash)
+    return !!arg
+  else if (arg === '--')
+    dashdash = true;
+  else if (arg === '--no-glob' || arg === '-G')
+    noglob = true;
+  else if (arg === '--glob' || arg === '-g')
+    noglob = false;
+  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> [<path> ...]');
+  log('');
+  log('  Deletes all files and folders at "path" recursively.');
+  log('');
+  log('Options:');
+  log('');
+  log('  -h, --help     Display this usage info');
+  log('  -G, --no-glob  Do not expand glob patterns in arguments');
+  log('  -g, --glob     Expand glob patterns in arguments (default)');
+  process.exit(help ? 0 : 1);
+} else
+  go(0);
+
+function go (n) {
+  if (n >= args.length)
+    return
+  var options = {};
+  if (noglob)
+    options = { glob: false };
+  rimraf(args[n], options, function (er) {
+    if (er)
+      throw er
+    go(n+1);
+  });
+}
+
+var binWithoutHashbang = {
+
+};
+
+module.exports = binWithoutHashbang;
diff --git a/package.json b/package.json
index ec817395..50632927 100644
--- a/package.json
+++ b/package.json
@@ -13,7 +13,7 @@
     "postinstall": "install-app-deps && npm run rebuild-node-pty",
     "rebuild-node-pty": "electron-rebuild -f -w app/node_modules/node-pty -m app",
     "dist": "npm run build && cross-env BABEL_ENV=production babel --out-file app/dist/bundle.js --no-comments --minified app/dist/bundle.js && build",
-    "clean": "npm cache clear && rm -rf node_modules && rm -rf app/node_modules && rm -rf app/dist"
+    "clean": "node ./bin/rimraf-standalone.js node_modules && node ./bin/rimraf-standalone.js ./app/node_modules && node ./bin/rimraf-standalone.js ./app/dist"
   },
   "xo": {
     "extends": "xo-react",
@@ -35,7 +35,8 @@
       "app/dist/**",
       "app/static/**",
       "assets/**",
-      "website/**"
+      "website/**",
+      "bin/**"
     ]
   },
   "babel": {