1 files changed, 225 insertions, 0 deletions
diff --git a/deps/node/deps/npm/node_modules/copy-concurrently/copy.js b/deps/node/deps/npm/node_modules/copy-concurrently/copy.js
new file mode 100644
index 00000000..36ce9f46
--- /dev/null
+++ b/deps/node/deps/npm/node_modules/copy-concurrently/copy.js
@@ -0,0 +1,225 @@
+'use strict'
+module.exports = copy
+module.exports.item = copyItem
+module.exports.recurse = recurseDir
+module.exports.symlink = copySymlink
+module.exports.file = copyFile
+
+var nodeFs = require('fs')
+var path = require('path')
+var validate = require('aproba')
+var stockWriteStreamAtomic = require('fs-write-stream-atomic')
+var mkdirp = require('mkdirp')
+var rimraf = require('rimraf')
+var isWindows = require('./is-windows')
+var RunQueue = require('run-queue')
+var extend = Object.assign || require('util')._extend
+
+function promisify (Promise, fn) {
+  return function () {
+    var args = [].slice.call(arguments)
+    return new Promise(function (resolve, reject) {
+      return fn.apply(null, args.concat(function (err, value) {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(value)
+        }
+      }))
+    })
+  }
+}
+
+function copy (from, to, opts) {
+  validate('SSO|SS', arguments)
+  opts = extend({}, opts || {})
+
+  var Promise = opts.Promise || global.Promise
+  var fs = opts.fs || nodeFs
+
+  if (opts.isWindows == null) opts.isWindows = isWindows
+  if (!opts.Promise) opts.Promise = Promise
+  if (!opts.fs) opts.fs = fs
+  if (!opts.recurseWith) opts.recurseWith = copyItem
+  if (!opts.lstat) opts.lstat = promisify(opts.Promise, fs.lstat)
+  if (!opts.stat) opts.stat = promisify(opts.Promise, fs.stat)
+  if (!opts.chown) opts.chown = promisify(opts.Promise, fs.chown)
+  if (!opts.readdir) opts.readdir = promisify(opts.Promise, fs.readdir)
+  if (!opts.readlink) opts.readlink = promisify(opts.Promise, fs.readlink)
+  if (!opts.symlink) opts.symlink = promisify(opts.Promise, fs.symlink)
+  if (!opts.chmod) opts.chmod = promisify(opts.Promise, fs.chmod)
+
+  opts.top = from
+  opts.mkdirpAsync = promisify(opts.Promise, mkdirp)
+  var rimrafAsync = promisify(opts.Promise, rimraf)
+
+  var queue = new RunQueue({
+    maxConcurrency: opts.maxConcurrency,
+    Promise: Promise
+  })
+  opts.queue = queue
+
+  queue.add(0, copyItem, [from, to, opts])
+
+  return queue.run().catch(function (err) {
+    // if the target already exists don't clobber it
+    if (err.code === 'EEXIST' || err.code === 'EPERM') {
+      return passThroughError()
+    } else {
+      return remove(to).then(passThroughError, passThroughError)
+    }
+    function passThroughError () {
+      return Promise.reject(err)
+    }
+  })
+
+  function remove (target) {
+    var opts = {
+      unlink: fs.unlink,
+      chmod: fs.chmod,
+      stat: fs.stat,
+      lstat: fs.lstat,
+      rmdir: fs.rmdir,
+      readdir: fs.readdir,
+      glob: false
+    }
+    return rimrafAsync(target, opts)
+  }
+}
+
+function copyItem (from, to, opts) {
+  validate('SSO', [from, to, opts])
+  var fs = opts.fs || nodeFs
+  var Promise = opts.Promise || global.Promise
+  var lstat = opts.lstat || promisify(Promise, fs.lstat)
+
+  return lstat(to).then(function () {
+    return Promise.reject(eexists(from, to))
+  }, function (err) {
+    if (err && err.code !== 'ENOENT') return Promise.reject(err)
+    return lstat(from)
+  }).then(function (fromStat) {
+    var cmdOpts = extend(extend({}, opts), fromStat)
+    if (fromStat.isDirectory()) {
+      return recurseDir(from, to, cmdOpts)
+    } else if (fromStat.isSymbolicLink()) {
+      opts.queue.add(1, copySymlink, [from, to, cmdOpts])
+    } else if (fromStat.isFile()) {
+      return copyFile(from, to, cmdOpts)
+    } else if (fromStat.isBlockDevice()) {
+      return Promise.reject(eunsupported(from + " is a block device, and we don't know how to copy those."))
+    } else if (fromStat.isCharacterDevice()) {
+      return Promise.reject(eunsupported(from + " is a character device, and we don't know how to copy those."))
+    } else if (fromStat.isFIFO()) {
+      return Promise.reject(eunsupported(from + " is a FIFO, and we don't know how to copy those."))
+    } else if (fromStat.isSocket()) {
+      return Promise.reject(eunsupported(from + " is a socket, and we don't know how to copy those."))
+    } else {
+      return Promise.reject(eunsupported("We can't tell what " + from + " is and so we can't copy it."))
+    }
+  })
+}
+
+function recurseDir (from, to, opts) {
+  validate('SSO', [from, to, opts])
+  var recurseWith = opts.recurseWith || copyItem
+  var fs = opts.fs || nodeFs
+  var chown = opts.chown || promisify(Promise, fs.chown)
+  var readdir = opts.readdir || promisify(Promise, fs.readdir)
+  var mkdirpAsync = opts.mkdirpAsync || promisify(Promise, mkdirp)
+
+  return mkdirpAsync(to, {fs: fs, mode: opts.mode}).then(function () {
+    var getuid = opts.getuid || process.getuid
+    if (getuid && opts.uid != null && getuid() === 0) {
+      return chown(to, opts.uid, opts.gid)
+    }
+  }).then(function () {
+    return readdir(from)
+  }).then(function (files) {
+    files.forEach(function (file) {
+      opts.queue.add(0, recurseWith, [path.join(from, file), path.join(to, file), opts])
+    })
+  })
+}
+
+function copySymlink (from, to, opts) {
+  validate('SSO', [from, to, opts])
+  var fs = opts.fs || nodeFs
+  var readlink = opts.readlink || promisify(Promise, fs.readlink)
+  var stat = opts.stat || promisify(Promise, fs.symlink)
+  var symlink = opts.symlink || promisify(Promise, fs.symlink)
+  var Promise = opts.Promise || global.Promise
+
+  return readlink(from).then(function (fromDest) {
+    var absoluteDest = path.resolve(path.dirname(from), fromDest)
+    // Treat absolute paths that are inside the tree we're
+    // copying as relative. This necessary to properly support junctions
+    // on windows (which are always absolute) but is also DWIM with symlinks.
+    var relativeDest = path.relative(opts.top, absoluteDest)
+    var linkFrom = relativeDest.substr(0, 2) === '..' ? fromDest : path.relative(path.dirname(from), absoluteDest)
+    if (opts.isWindows) {
+      return stat(absoluteDest).catch(function () { return null }).then(function (destStat) {
+        var isDir = destStat && destStat.isDirectory()
+        var type = isDir ? 'dir' : 'file'
+        return symlink(linkFrom, to, type).catch(function (err) {
+          if (type === 'dir') {
+            return symlink(linkFrom, to, 'junction')
+          } else {
+            return Promise.reject(err)
+          }
+        })
+      })
+    } else {
+      return symlink(linkFrom, to)
+    }
+  })
+}
+
+function copyFile (from, to, opts) {
+  validate('SSO', [from, to, opts])
+  var fs = opts.fs || nodeFs
+  var writeStreamAtomic = opts.writeStreamAtomic || stockWriteStreamAtomic
+  var Promise = opts.Promise || global.Promise
+  var chmod = opts.chmod || promisify(Promise, fs.chmod)
+
+  var writeOpts = {}
+  var getuid = opts.getuid || process.getuid
+  if (getuid && opts.uid != null && getuid() === 0) {
+    writeOpts.chown = {
+      uid: opts.uid,
+      gid: opts.gid
+    }
+  }
+
+  return new Promise(function (resolve, reject) {
+    var errored = false
+    function onError (err) {
+      errored = true
+      reject(err)
+    }
+    fs.createReadStream(from)
+      .once('error', onError)
+      .pipe(writeStreamAtomic(to, writeOpts))
+      .once('error', onError)
+      .once('close', function () {
+        if (errored) return
+        if (opts.mode != null) {
+          resolve(chmod(to, opts.mode))
+        } else {
+          resolve()
+        }
+      })
+  })
+}
+
+function eexists (from, to) {
+  var err = new Error('Could not move ' + from + ' to ' + to + ': destination already exists.')
+  err.code = 'EEXIST'
+  return err
+}
+
+function eunsupported (msg) {
+  var err = new Error(msg)
+  err.code = 'EUNSUPPORTED'
+  return err
+}