Added Gulp.js for compiling SCSS stylesheets

2022-11-01 18:49:18 -04:00
parent 7c793dac88
commit 91f72d4893
2956 changed files with 361906 additions and 7 deletions
--- a/node_modules/gulp-cli/LICENSE
+++ b/node_modules/gulp-cli/LICENSE
@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Blaine Bublitz, Eric Schoffstall and other 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.
--- a/node_modules/gulp-cli/README.md
+++ b/node_modules/gulp-cli/README.md
@ -0,0 +1,240 @@
+<p align="center">
+  <a href="http://gulpjs.com">
+    <img height="257" width="114" src="https://raw.githubusercontent.com/gulpjs/artwork/master/gulp-2x.png">
+  </a>
+</p>
+
+# gulp-cli
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url]
+
+Command Line Utility for Gulp
+
+## Usage
+
+```bash
+> gulp [flags] <task> <task>...
+```
+
+## Custom Metadata
+
+When listing tasks with the `gulp -T` command, gulp-cli displays some custom metadata as defined upon task functions. Currently supported properties:
+
+* `task.description` - String of the description to display.
+
+```js
+function clean() { ... }
+clean.description = 'Cleans up generated files.';
+```
+
+* `task.flags` - Object with key/value pairs being flag/description to display.
+
+```js
+function build() { ... }
+build.flags = {
+  '--prod': 'Builds in production mode.'
+};
+```
+
+Example Usage:
+
+```js
+function build() { ... }
+build.description = 'Build entire project.';
+build.flags = {
+  '--prod': 'Builds in production mode (minification, etc).'
+};
+// gulp 3.x
+gulp.task('build', build);
+// gulp 4.x
+gulp.task(build);
+```
+
+## Tasks
+
+The task(s) listed on the command line will be executed.
+If more than one task is listed, Gulp will execute all of them
+concurrently, that is, as if they had all been listed as dependencies of
+a single task.
+
+By default, Gulp does not serialize tasks listed on the command line. If you would like to execute tasks serially, you must specify the `--series` flag. e.g. `gulp clean build --series`
+
+Just running `gulp` will execute the task `default`. If there is no
+`default` task, gulp will error.
+
+## Completion
+> Thanks to the grunt team, specifically Tyler Kellen
+
+To enable tasks auto-completion in shell you should add `eval "$(gulp --completion=shell)"` in your `.shellrc` file.
+
+###### Bash:
+
+Add `eval "$(gulp --completion=bash)"` to `~/.bashrc`.
+
+###### Zsh:
+
+Add `eval "$(gulp --completion=zsh)"` to `~/.zshrc`.
+
+###### Powershell:
+
+Add `Invoke-Expression ((gulp --completion=powershell) -join [System.Environment]::NewLine)` to `$PROFILE`.
+
+###### Fish:
+
+Add `gulp --completion=fish | source` to `~/.config/fish/config.fish`.
+
+## Compilers
+
+You can find a list of supported languages at https://github.com/js-cli/js-interpret. If you would like to add support for a new language, send pull requests/open issues on that project.
+
+## Environment
+
+The CLI adds process.env.INIT_CWD which is the original cwd it was launched from.
+
+## Configuration
+
+Configuration is supported through the use of a `.gulp.*` file (e.g. `.gulp.json`, `.gulp.yml`). You can find a list of supported languages at https://github.com/js-cli/js-interpret.
+
+Configuration from the home directory (`~`) and current working directory (`cwd`) are merged with `cwd` taking precedence.
+
+Supported configurations properties:
+
+| Property           | Description |
+|--------------------|-------------|
+| description        | Top-level description of the project/gulpfile (Replaces "Tasks for ~/path/of/gulpfile.js") |
+| flags.continue     | Continue execution of tasks upon failure by default. |
+| flags.compactTasks | Reduce the output of task dependency tree by default. |
+| flags.tasksDepth   | Set default depth of task dependency tree. |
+| flags.gulpfile     | Set a default gulpfile |
+| flags.silent       | Silence logging by default |
+| flags.series       | Run tasks given on the CLI in series (the default is parallel) |
+| flags.require      | An array of modules to require before running the gulpfile. Any relative paths will be resolved against the `--cwd` directory (if you don't want that behavior, use absolute paths) |
+| flags.nodeFlags    | An array of flags used to forcibly respawn the process upon startup. For example, if you always want your gulpfiles to run in node's harmony mode, you can set `--harmony` here |
+
+## Flags
+
+gulp has very few flags to know about. All other flags are for tasks to use if needed.
+
+__Some flags only work with gulp 4 and will be ignored when invoked against gulp 3.__
+
+<table>
+  <thead>
+    <tr>
+      <th width="25%">Flag</th>
+      <th width="15%">Short Flag</th>
+      <th>Description</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>--help</td>
+      <td>-h</td>
+      <td>Show this help.</td>
+    </tr>
+    <tr>
+      <td>--version</td>
+      <td>-v</td>
+      <td>Print the global and local gulp versions.</td>
+    </tr>
+    <tr>
+      <td>--require [path]</td>
+      <td></td>
+      <td>Will require a module before running the gulpfile. This is useful for transpilers but also has other applications.</td>
+    </tr>
+    <tr>
+      <td>--gulpfile [path]</td>
+      <td>-f</td>
+      <td>Manually set path of gulpfile. Useful if you have multiple gulpfiles. This will set the CWD to the gulpfile directory as well.</td>
+    </tr>
+    <tr>
+      <td>--cwd [path]</td>
+      <td></td>
+      <td>Manually set the CWD. The search for the gulpfile, as well as the relativity of all requires (including the `--require` flag) will be from here.</td>
+    </tr>
+    <tr>
+      <td>--verify [path (optional)]</td>
+      <td></td>
+      <td>Will verify plugins referenced in project's package.json against the plugins blacklist.</td>
+    </tr>
+    <tr>
+      <td>--tasks</td>
+      <td>-T</td>
+      <td>Print the task dependency tree for the loaded gulpfile.</td>
+    </tr>
+    <tr>
+      <td>--tasks-simple</td>
+      <td></td>
+      <td>Print a plaintext list of tasks for the loaded gulpfile.</td>
+    </tr>
+    <tr>
+      <td>--tasks-json [path]</td>
+      <td></td>
+      <td>Print the task dependency tree, in JSON format, for the loaded gulpfile. The [path] argument is optional, and if given writes the JSON to the path.</td>
+    </tr>
+    <tr>
+      <td>--tasks-depth [number]</td>
+      <td></td>
+      <td>Specify the depth of the task dependency tree to print. This flag can be used with --tasks or --tasks-json. (This flag was named --depth before but is deprecated.)</td>
+    </tr>
+    <tr>
+      <td>--compact-tasks</td>
+      <td></td>
+      <td>Reduce the output of task dependency tree by printing only top tasks and their child tasks. This flag can be used with --tasks or --tasks-json.</td>
+    </tr>
+    <tr>
+      <td>--sort-tasks</td>
+      <td></td>
+      <td>Will sort top tasks of task dependency tree. This flag can be used with --tasks.</td>
+    </tr>
+    <tr>
+      <td>--color</td>
+      <td></td>
+      <td>Will force gulp and gulp plugins to display colors, even when no color support is detected.</td>
+    </tr>
+    <tr>
+      <td>--no-color</td>
+      <td></td>
+      <td>Will force gulp and gulp plugins to not display colors, even when color support is detected.</td>
+    </tr>
+    <tr>
+      <td>--silent</td>
+      <td>-S</td>
+      <td>Suppress all gulp logging.</td>
+    </tr>
+    <tr>
+      <td>--continue</td>
+      <td></td>
+      <td>Continue execution of tasks upon failure.</td>
+    </tr>
+    <tr>
+      <td>--series</td>
+      <td></td>
+      <td>Run tasks given on the CLI in series (the default is parallel).</td>
+    </tr>
+    <tr>
+      <td>--log-level</td>
+      <td>-L</td>
+      <td>Set the loglevel. -L for least verbose and -LLLL for most verbose. -LLL is default.</td>
+    </tr>
+  </tbody>
+</table>
+
+## License
+
+MIT
+
+[downloads-image]: http://img.shields.io/npm/dm/gulp-cli.svg
+[npm-url]: https://www.npmjs.com/package/gulp-cli
+[npm-image]: http://img.shields.io/npm/v/gulp-cli.svg
+
+[travis-url]: https://travis-ci.org/gulpjs/gulp-cli
+[travis-image]: http://img.shields.io/travis/gulpjs/gulp-cli.svg?label=travis-ci
+
+[appveyor-url]: https://ci.appveyor.com/project/gulpjs/gulp-cli
+[appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/gulp-cli.svg?label=appveyor
+
+[coveralls-url]: https://coveralls.io/r/gulpjs/gulp-cli
+[coveralls-image]: http://img.shields.io/coveralls/gulpjs/gulp-cli/master.svg
+
+[gitter-url]: https://gitter.im/gulpjs/gulp
+[gitter-image]: https://badges.gitter.im/gulpjs/gulp.svg
--- a/node_modules/gulp-cli/bin/gulp.js
+++ b/node_modules/gulp-cli/bin/gulp.js
@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+'use strict';
+
+require('../')();
--- a/node_modules/gulp-cli/completion/README.md
+++ b/node_modules/gulp-cli/completion/README.md
@ -0,0 +1,20 @@
+# Completion for gulp
+> Thanks to the grunt team, specifically Tyler Kellen
+
+To enable tasks auto-completion in shell you should add `eval "$(gulp --completion=shell)"` in your `.shellrc` file.
+
+## Bash
+
+Add `eval "$(gulp --completion=bash)"` to `~/.bashrc`.
+
+## Zsh
+
+Add `eval "$(gulp --completion=zsh)"` to `~/.zshrc`.
+
+## Powershell
+
+Add `Invoke-Expression ((gulp --completion=powershell) -join [System.Environment]::NewLine)` to `$PROFILE`.
+
+## Fish
+
+Add `gulp --completion=fish | source` to `~/.config/fish/config.fish`.
--- a/node_modules/gulp-cli/completion/bash
+++ b/node_modules/gulp-cli/completion/bash
@ -0,0 +1,27 @@
+#!/bin/bash
+
+# Borrowed from grunt-cli
+# http://gruntjs.com/
+#
+# Copyright (c) 2012 Tyler Kellen, contributors
+# Licensed under the MIT license.
+# https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+
+# Usage:
+#
+# To enable bash <tab> completion for gulp, add the following line (minus the
+# leading #, which is the bash comment character) to your ~/.bashrc file:
+#
+# eval "$(gulp --completion=bash)"
+
+# Enable bash autocompletion.
+function _gulp_completions() {
+  # The currently-being-completed word.
+  local cur="${COMP_WORDS[COMP_CWORD]}"
+  #Grab tasks
+  local compls=$(gulp --tasks-simple)
+  # Tell complete what stuff to show.
+  COMPREPLY=($(compgen -W "$compls" -- "$cur"))
+}
+
+complete -o default -F _gulp_completions gulp
--- a/node_modules/gulp-cli/completion/fish
+++ b/node_modules/gulp-cli/completion/fish
@ -0,0 +1,10 @@
+#!/usr/bin/env fish
+
+# Usage:
+#
+# To enable fish <tab> completion for gulp, add the following line to
+# your ~/.config/fish/config.fish file:
+#
+# gulp --completion=fish | source
+
+complete -c gulp -a "(gulp --tasks-simple)" -f
--- a/node_modules/gulp-cli/completion/powershell
+++ b/node_modules/gulp-cli/completion/powershell
@ -0,0 +1,61 @@
+# Copyright (c) 2014 Jason Jarrett
+#
+# Tab completion for the `gulp`
+#
+# Usage:
+#
+# To enable powershell <tab> completion for gulp you need to be running 
+# at least PowerShell v3 or greater and add the below to your $PROFILE
+#
+#     Invoke-Expression ((gulp --completion=powershell) -join [System.Environment]::NewLine)
+#
+#
+
+$gulp_completion_Process = {
+    param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameter)
+
+
+	# Load up an assembly to read the gulpfile's sha1
+	if(-not $global:GulpSHA1Managed) {
+		[Reflection.Assembly]::LoadWithPartialName("System.Security") | out-null
+		$global:GulpSHA1Managed = new-Object System.Security.Cryptography.SHA1Managed
+	}
+
+	# setup a global (in-memory) cache
+	if(-not $global:GulpfileShaCache) {
+		$global:GulpfileShaCache = @{};
+	}
+
+	$cache = $global:GulpfileShaCache;
+
+	# Get the gulpfile's sha1
+	$sha1gulpFile = (resolve-path gulpfile.js -ErrorAction Ignore | %{
+		$file = [System.IO.File]::Open($_.Path, "open", "read")
+		[string]::join('', ($global:GulpSHA1Managed.ComputeHash($file) | %{ $_.ToString("x2") }))
+		$file.Dispose()
+	})
+
+	# lookup the sha1 for previously cached task lists.
+	if($cache.ContainsKey($sha1gulpFile)){
+		$tasks = $cache[$sha1gulpFile];
+	} else {
+		$tasks = (gulp --tasks-simple).split("`n");
+		$cache[$sha1gulpFile] = $tasks;
+	}
+
+
+    $tasks |
+        where { $_.startswith($commandName) }
+        Sort-Object |
+        foreach { New-Object System.Management.Automation.CompletionResult $_, $_, 'ParameterValue', ('{0}' -f $_) }
+}
+
+if (-not $global:options) {
+    $global:options = @{
+        CustomArgumentCompleters = @{};
+        NativeArgumentCompleters = @{}
+    }
+}
+
+$global:options['NativeArgumentCompleters']['gulp'] = $gulp_completion_Process
+$function:tabexpansion2 = $function:tabexpansion2 -replace 'End\r\n{','End { if ($null -ne $options) { $options += $global:options} else {$options = $global:options}'
--- a/node_modules/gulp-cli/completion/zsh
+++ b/node_modules/gulp-cli/completion/zsh
@ -0,0 +1,25 @@
+#!/bin/zsh
+
+# Borrowed from grunt-cli
+# http://gruntjs.com/
+#
+# Copyright (c) 2012 Tyler Kellen, contributors
+# Licensed under the MIT license.
+# https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT
+
+# Usage:
+#
+# To enable zsh <tab> completion for gulp, add the following line (minus the
+# leading #, which is the zsh comment character) to your ~/.zshrc file:
+#
+# eval "$(gulp --completion=zsh)"
+
+# Enable zsh autocompletion.
+function _gulp_completion() {
+  # Grab tasks
+  compls=$(gulp --tasks-simple)
+  completions=(${=compls})
+  compadd -- $completions
+}
+
+compdef _gulp_completion gulp
--- a/node_modules/gulp-cli/gulp.1
+++ b/node_modules/gulp-cli/gulp.1
@ -0,0 +1,83 @@
+.TH "GULP" "" "June 2020" "" ""
+.SH "NAME"
+\fBgulp\fR
+.SS Usage
+.P
+\fBgulp [flags] <task> <task>\.\.\.\fP
+.SS Tasks
+.P
+The task(s) listed will be executed\.
+If more than one task is listed, Gulp will execute all of them
+concurrently, that is, as if they had all been listed as dependencies of
+a single task\.
+.P
+By default, Gulp does not serialize tasks listed on the command line\. If you would like to execute tasks serially, you must specify the \fB\-\-series\fP flag\. e\.g\. \fBgulp clean build \-\-series\fP
+.P
+Just running \fBgulp\fP will execute the task \fBdefault\fP\|\. If there is no
+\fBdefault\fP task, gulp will error\.
+.SS Compilers
+.P
+You can find a list of supported languages at https:// If you would like to add support for a new language, send pull requests/open issues on that project\.
+.SS Environment
+.P
+The CLI adds process\.env\.INIT_CWD which is the original cwd it was launched from\.
+.SS Flags
+.P
+gulp has very few flags to know about\. All other flags are for tasks to use if needed\.
+.P
+\fBSome flags only work with gulp 4 and will be ignored when invoked against gulp 3\.\fR
+.P
+\fB\-\-help\fR, \fB\-h\fR
+    Show the help\.
+.P
+\fB\-\-version\fR, \fB\-v\fR
+    Print the global and local gulp versions\.
+.P
+\fB\-\-require\fR [path]
+    Will require a module before running the gulpfile\. This is useful for transpilers but also has other applications\.
+.P
+\fB\-\-gulpfile\fR [path], \fB\-f\fR [path]
+    Manually set path of gulpfile\. Useful if you have multiple gulpfiles\. This will set the CWD to the gulpfile directory as well\.
+.P
+\fB\-\-cwd\fR [path]
+    Manually set the CWD\. The search for the gulpfile, as well as the relativity of all requires will be from here\.
+.P
+\fB\-\-verify\fR [path (optional)]
+    Will verify plugins referenced in project's package\.json against the plugins blacklist\.
+.P
+\fB\-\-tasks\fR, \fB\-T\fR
+    Print the task dependency tree for the loaded gulpfile\.
+.P
+\fB\-\-tasks\-simple\fR
+    Print a plaintext list of tasks for the loaded gulpfile\.
+.P
+\fB\-\-tasks\-json\fR [path]
+    Print the task dependency tree, in JSON format, for the loaded gulpfile\. The [path] argument is optional, and if given writes the JSON to the path\.
+.P
+\fB\-\-tasks\-depth\fR [number]
+    Specify the depth of the task dependency tree to print\. This flag can be used with \-\-tasks or \-\-tasks\-json\. (This flag was named \-\-depth before but is deprecated\.)
+.P
+\fB\-\-compact\-tasks\fR
+    Reduce the output of task dependency tree by printing only top tasks and their child tasks\. This flag can be used with \-\-tasks or \-\-tasks\-json\.
+.P
+\fB\-\-sort\-tasks\fR
+    Will sort top tasks of task dependency tree\. This flag can be used with \-\-tasks\.
+.P
+\fB\-\-color\fR
+    Will force gulp and gulp plugins to display colors, even when no color support is detected\.
+.P
+\fB\-\-no\-color\fR
+    Will force gulp and gulp plugins to not display colors, even when color support is detected\.
+.P
+\fB\-\-silent\fR, \fB\-S\fR
+    Suppress all gulp logging\.
+.P
+\fB\-\-continue\fR
+    Continue execution of tasks upon failure\.
+.P
+\fB\-\-series\fR
+    Run tasks given on the CLI in series (the default is parallel)\.
+.P
+\fB\-\-log\-level\fR, \fB\-L\fR
+    Set the loglevel\. \-L for least verbose and \-LLLL for most verbose\. \-LLL is default\.
+
--- a/node_modules/gulp-cli/index.js
+++ b/node_modules/gulp-cli/index.js
@ -0,0 +1,212 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var log = require('gulplog');
+var yargs = require('yargs');
+var Liftoff = require('liftoff');
+var interpret = require('interpret');
+var v8flags = require('v8flags');
+var findRange = require('semver-greatest-satisfied-range');
+var ansi = require('./lib/shared/ansi');
+var exit = require('./lib/shared/exit');
+var tildify = require('./lib/shared/tildify');
+var makeTitle = require('./lib/shared/make-title');
+var cliOptions = require('./lib/shared/cli-options');
+var completion = require('./lib/shared/completion');
+var verifyDeps = require('./lib/shared/verify-dependencies');
+var cliVersion = require('./package.json').version;
+var getBlacklist = require('./lib/shared/get-blacklist');
+var toConsole = require('./lib/shared/log/to-console');
+
+var loadConfigFiles = require('./lib/shared/config/load-files');
+var mergeConfigToCliFlags = require('./lib/shared/config/cli-flags');
+var mergeConfigToEnvFlags = require('./lib/shared/config/env-flags');
+
+// Logging functions
+var logVerify = require('./lib/shared/log/verify');
+var logBlacklistError = require('./lib/shared/log/blacklist-error');
+
+// Get supported ranges
+var ranges = fs.readdirSync(path.join(__dirname, '/lib/versioned/'));
+
+// Set env var for ORIGINAL cwd
+// before anything touches it
+process.env.INIT_CWD = process.cwd();
+
+var cli = new Liftoff({
+  name: 'gulp',
+  processTitle: makeTitle('gulp', process.argv.slice(2)),
+  completions: completion,
+  extensions: interpret.jsVariants,
+  v8flags: v8flags,
+  configFiles: {
+    '.gulp': {
+      home: {
+        path: '~',
+        extensions: interpret.extensions,
+      },
+      cwd: {
+        path: '.',
+        extensions: interpret.extensions,
+      },
+    },
+  },
+});
+
+var usage =
+  '\n' + ansi.bold('Usage:') +
+  ' gulp ' + ansi.blue('[options]') + ' tasks';
+
+var parser = yargs.usage(usage, cliOptions);
+var opts = parser.argv;
+
+cli.on('require', function(name) {
+  // This is needed because interpret needs to stub the .mjs extension
+  // Without the .mjs require hook, rechoir blows up
+  // However, we don't want to show the mjs-stub loader in the logs
+  if (path.basename(name, '.js') !== 'mjs-stub') {
+    log.info('Requiring external module', ansi.magenta(name));
+  }
+});
+
+cli.on('requireFail', function(name, error) {
+  log.warn(
+    ansi.yellow('Failed to load external module'),
+    ansi.magenta(name)
+  );
+  /* istanbul ignore else */
+  if (error) {
+    log.warn(ansi.yellow(error.toString()));
+  }
+});
+
+cli.on('respawn', function(flags, child) {
+  var nodeFlags = ansi.magenta(flags.join(', '));
+  var pid = ansi.magenta(child.pid);
+  log.info('Node flags detected:', nodeFlags);
+  log.info('Respawned to PID:', pid);
+});
+
+function run() {
+  cli.prepare({
+    cwd: opts.cwd,
+    configPath: opts.gulpfile,
+    require: opts.require,
+    completion: opts.completion,
+  }, function(env) {
+    var cfgLoadOrder = ['home', 'cwd'];
+    var cfg = loadConfigFiles(env.configFiles['.gulp'], cfgLoadOrder);
+    opts = mergeConfigToCliFlags(opts, cfg);
+    env = mergeConfigToEnvFlags(env, cfg, opts);
+    env.configProps = cfg;
+
+    // Set up event listeners for logging again after configuring.
+    toConsole(log, opts);
+
+    cli.execute(env, env.nodeFlags, handleArguments);
+  });
+}
+
+module.exports = run;
+
+// The actual logic
+function handleArguments(env) {
+
+  // This translates the --continue flag in gulp
+  // To the settle env variable for undertaker
+  // We use the process.env so the user's gulpfile
+  // Can know about the flag
+  if (opts.continue) {
+    process.env.UNDERTAKER_SETTLE = 'true';
+  }
+
+  if (opts.help) {
+    parser.showHelp(console.log);
+    exit(0);
+  }
+
+  // Anything that needs to print outside of the logging mechanism should use console.log
+  if (opts.version) {
+    console.log('CLI version:', cliVersion);
+    console.log('Local version:', env.modulePackage.version || 'Unknown');
+    exit(0);
+  }
+
+  if (opts.verify) {
+    var pkgPath = opts.verify !== true ? opts.verify : 'package.json';
+    /* istanbul ignore else */
+    if (path.resolve(pkgPath) !== path.normalize(pkgPath)) {
+      pkgPath = path.join(env.cwd, pkgPath);
+    }
+    log.info('Verifying plugins in ' + pkgPath);
+    return getBlacklist(function(err, blacklist) {
+      /* istanbul ignore if */
+      if (err) {
+        return logBlacklistError(err);
+      }
+
+      var blacklisted = verifyDeps(require(pkgPath), blacklist);
+
+      logVerify(blacklisted);
+    });
+  }
+
+  if (!env.modulePath) {
+    /* istanbul ignore next */
+    var missingNodeModules =
+      fs.existsSync(path.join(env.cwd, 'package.json'))
+      && !fs.existsSync(path.join(env.cwd, 'node_modules'));
+
+    /* istanbul ignore next */
+    var missingGulpMessage =
+      missingNodeModules
+        ? 'Local modules not found in'
+        : 'Local gulp not found in';
+    log.error(
+      ansi.red(missingGulpMessage),
+      ansi.magenta(tildify(env.cwd))
+    );
+    var hasYarn = fs.existsSync(path.join(env.cwd, 'yarn.lock'));
+    /* istanbul ignore next */
+    var installCommand =
+      missingNodeModules
+        ? hasYarn
+          ? 'yarn install'
+          : 'npm install'
+        : hasYarn
+          ? 'yarn add gulp'
+        : 'npm install gulp';
+    log.error(ansi.red('Try running: ' + installCommand));
+    exit(1);
+  }
+
+  if (!env.configPath) {
+    log.error(ansi.red('No gulpfile found'));
+    exit(1);
+  }
+
+  // Chdir before requiring gulpfile to make sure
+  // we let them chdir as needed
+  if (process.cwd() !== env.cwd) {
+    process.chdir(env.cwd);
+    log.info(
+      'Working directory changed to',
+      ansi.magenta(tildify(env.cwd))
+    );
+  }
+
+  // Find the correct CLI version to run
+  var range = findRange(env.modulePackage.version, ranges);
+
+  if (!range) {
+    log.error(
+      ansi.red('Unsupported gulp version', env.modulePackage.version)
+    );
+    exit(1);
+  }
+
+  // Load and execute the CLI version
+  var versionedDir = path.join(__dirname, '/lib/versioned/', range, '/');
+  require(versionedDir)(opts, env, env.configProps);
+}
--- a/node_modules/gulp-cli/lib/shared/ansi.js
+++ b/node_modules/gulp-cli/lib/shared/ansi.js
@ -0,0 +1,41 @@
+'use strict';
+
+var colors = require('ansi-colors');
+var supportsColor = require('color-support');
+
+var hasColors = colorize();
+
+/* istanbul ignore next */
+module.exports = {
+  red: hasColors ? colors.red : noColor,
+  green: hasColors ? colors.green : noColor,
+  blue: hasColors ? colors.blue : noColor,
+  magenta: hasColors ? colors.magenta : noColor,
+  cyan: hasColors ? colors.cyan : noColor,
+  white: hasColors ? colors.white : noColor,
+  gray: hasColors ? colors.gray : noColor,
+  bgred: hasColors ? colors.bgred : noColor,
+  bold: hasColors ? colors.bold : noColor,
+  yellow: hasColors ? colors.yellow : noColor,
+};
+
+function noColor(message) {
+  return message;
+}
+
+function hasFlag(flag) {
+  return (process.argv.indexOf('--' + flag) !== -1);
+}
+
+function colorize() {
+  if (hasFlag('no-color')) {
+    return false;
+  }
+
+  /* istanbul ignore if */
+  if (hasFlag('color')) {
+    return true;
+  }
+
+  return supportsColor();
+}
--- a/node_modules/gulp-cli/lib/shared/cli-options.js
+++ b/node_modules/gulp-cli/lib/shared/cli-options.js
@ -0,0 +1,122 @@
+'use strict';
+
+var ansi = require('./ansi');
+
+module.exports = {
+  help: {
+    alias: 'h',
+    type: 'boolean',
+    desc: ansi.gray(
+      'Show this help.'),
+  },
+  version: {
+    alias: 'v',
+    type: 'boolean',
+    desc: ansi.gray(
+      'Print the global and local gulp versions.'),
+  },
+  require: {
+    type: 'string',
+    requiresArg: true,
+    desc: ansi.gray(
+      'Will require a module before running the gulpfile. ' +
+      'This is useful for transpilers but also has other applications.'),
+  },
+  gulpfile: {
+    alias: 'f',
+    type: 'string',
+    requiresArg: true,
+    desc: ansi.gray(
+      'Manually set path of gulpfile. Useful if you have multiple gulpfiles. ' +
+      'This will set the CWD to the gulpfile directory as well.'),
+  },
+  cwd: {
+    type: 'string',
+    requiresArg: true,
+    desc: ansi.gray(
+      'Manually set the CWD. The search for the gulpfile, ' +
+      'as well as the relativity of all requires will be from here.'),
+  },
+  verify: {
+    desc: ansi.gray(
+      'Will verify plugins referenced in project\'s package.json against ' +
+      'the plugins blacklist.'),
+  },
+  tasks: {
+    alias: 'T',
+    type: 'boolean',
+    desc: ansi.gray(
+      'Print the task dependency tree for the loaded gulpfile.'),
+  },
+  'tasks-simple': {
+    type: 'boolean',
+    desc: ansi.gray(
+      'Print a plaintext list of tasks for the loaded gulpfile.'),
+  },
+  'tasks-json': {
+    desc: ansi.gray(
+      'Print the task dependency tree, ' +
+      'in JSON format, for the loaded gulpfile.'),
+  },
+  'tasks-depth': {
+    alias: 'depth',
+    type: 'number',
+    requiresArg: true,
+    default: undefined,  // To detect if this cli option is specified.
+    desc: ansi.gray(
+      'Specify the depth of the task dependency tree.'),
+  },
+  'compact-tasks': {
+    type: 'boolean',
+    default: undefined,  // To detect if this cli option is specified.
+    desc: ansi.gray(
+      'Reduce the output of task dependency tree by printing ' +
+      'only top tasks and their child tasks.'),
+  },
+  'sort-tasks': {
+    type: 'boolean',
+    default: undefined,  // To detect if this cli option is specified.
+    desc: ansi.gray(
+      'Will sort top tasks of task dependency tree.'),
+  },
+  color: {
+    type: 'boolean',
+    desc: ansi.gray(
+      'Will force gulp and gulp plugins to display colors, ' +
+      'even when no color support is detected.'),
+  },
+  'no-color': {
+    type: 'boolean',
+    desc: ansi.gray(
+      'Will force gulp and gulp plugins to not display colors, ' +
+      'even when color support is detected.'),
+  },
+  silent: {
+    alias: 'S',
+    type: 'boolean',
+    default: undefined,  // To detect if this cli option is specified.
+    desc: ansi.gray(
+      'Suppress all gulp logging.'),
+  },
+  continue: {
+    type: 'boolean',
+    default: undefined,  // To detect if this cli option is specified.
+    desc: ansi.gray(
+      'Continue execution of tasks upon failure.'),
+  },
+  series: {
+    type: 'boolean',
+    default: undefined,  // To detect if this cli option is specified.
+    desc: ansi.gray(
+      'Run tasks given on the CLI in series (the default is parallel).'),
+  },
+  'log-level': {
+    alias: 'L',
+    // Type isn't needed because count acts as a boolean
+    count: true,
+    default: undefined,  // To detect if this cli option is specified.
+    desc: ansi.gray(
+      'Set the loglevel. -L for least verbose and -LLLL for most verbose. ' +
+      '-LLL is default.'),
+  },
+};
--- a/node_modules/gulp-cli/lib/shared/completion.js
+++ b/node_modules/gulp-cli/lib/shared/completion.js
@ -0,0 +1,22 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+
+module.exports = function(name) {
+  if (typeof name !== 'string') {
+    throw new Error('Missing completion type');
+  }
+  var file = path.join(__dirname, '../../completion', name);
+  try {
+    console.log(fs.readFileSync(file, 'utf8'));
+    process.exit(0);
+  } catch (err) {
+    console.log(
+      'echo "gulp autocompletion rules for',
+      '\'' + name + '\'',
+      'not found"'
+    );
+    process.exit(5);
+  }
+};
--- a/node_modules/gulp-cli/lib/shared/config/cli-flags.js
+++ b/node_modules/gulp-cli/lib/shared/config/cli-flags.js
@ -0,0 +1,25 @@
+'use strict';
+
+var copyProps = require('copy-props');
+
+var fromTo = {
+  'flags.silent': 'silent',
+  'flags.continue': 'continue',
+  'flags.series': 'series',
+  'flags.logLevel': 'logLevel',
+  'flags.compactTasks': 'compactTasks',
+  'flags.tasksDepth': 'tasksDepth',
+  'flags.sortTasks': 'sortTasks',
+};
+
+function mergeConfigToCliFlags(opt, config) {
+  return copyProps(config, opt, fromTo, defaults);
+}
+
+function defaults(cfgInfo, optInfo) {
+  if (optInfo.value === undefined) {
+    return cfgInfo.value;
+  }
+}
+
+module.exports = mergeConfigToCliFlags;
--- a/node_modules/gulp-cli/lib/shared/config/env-flags.js
+++ b/node_modules/gulp-cli/lib/shared/config/env-flags.js
@ -0,0 +1,44 @@
+'use strict';
+
+var path = require('path');
+var copyProps = require('copy-props');
+
+var toFrom = {
+  configPath: 'flags.gulpfile',
+  configBase: 'flags.gulpfile',
+  require: 'flags.require',
+  nodeFlags: 'flags.nodeFlags',
+};
+
+function mergeConfigToEnvFlags(env, config, cliOpts) {
+  // This must reverse because `flags.gulpfile` determines 2 different properties
+  var reverse = true;
+  return copyProps(env, config, toFrom, convert, reverse);
+
+  function convert(configInfo, envInfo) {
+    if (envInfo.keyChain === 'configBase') {
+      if (cliOpts.gulpfile === undefined) {
+        return path.dirname(configInfo.value);
+      }
+      return;
+    }
+
+    if (envInfo.keyChain === 'configPath') {
+      if (cliOpts.gulpfile === undefined) {
+        return configInfo.value;
+      }
+      return;
+    }
+
+    if (envInfo.keyChain === 'require') {
+      return [].concat(envInfo.value, configInfo.value);
+    }
+
+    /* istanbul ignore else */
+    if (envInfo.keyChain === 'nodeFlags') {
+      return [].concat(configInfo.value || []);
+    }
+  }
+}
+
+module.exports = mergeConfigToEnvFlags;
--- a/node_modules/gulp-cli/lib/shared/config/load-files.js
+++ b/node_modules/gulp-cli/lib/shared/config/load-files.js
@ -0,0 +1,30 @@
+'use strict';
+
+var copyProps = require('copy-props');
+var path = require('path');
+
+function loadConfigFiles(configFiles, configFileOrder) {
+  var config = {};
+
+  configFileOrder.forEach(loadFile);
+
+  function loadFile(key) {
+    var filePath = configFiles[key];
+    if (!filePath) {
+      return;
+    }
+
+    copyProps(require(filePath), config, convert);
+
+    function convert(loadedInfo) {
+      if (loadedInfo.keyChain === 'flags.gulpfile') {
+        return path.resolve(path.dirname(filePath), loadedInfo.value);
+      }
+      return loadedInfo.value;
+    }
+  }
+
+  return config;
+}
+
+module.exports = loadConfigFiles;
--- a/node_modules/gulp-cli/lib/shared/exit.js
+++ b/node_modules/gulp-cli/lib/shared/exit.js
@ -0,0 +1,15 @@
+'use strict';
+
+// Fix stdout truncation on windows
+function exit(code) {
+  /* istanbul ignore next */
+  if (process.platform === 'win32' && process.stdout.bufferSize) {
+    process.stdout.once('drain', function() {
+      process.exit(code);
+    });
+    return;
+  }
+  process.exit(code);
+}
+
+module.exports = exit;
--- a/node_modules/gulp-cli/lib/shared/get-blacklist.js
+++ b/node_modules/gulp-cli/lib/shared/get-blacklist.js
@ -0,0 +1,62 @@
+'use strict';
+
+var https = require('https');
+
+var concat = require('concat-stream');
+
+var url = 'https://raw.githubusercontent.com/gulpjs/plugins/master/src/blackList.json';
+
+function collect(stream, cb) {
+  stream.on('error', cb);
+  stream.pipe(concat(onSuccess));
+
+  function onSuccess(result) {
+    cb(null, result);
+  }
+}
+
+function parse(str, cb) {
+  try {
+    cb(null, JSON.parse(str));
+  } catch (err) {
+    /* istanbul ignore next */
+    cb(new Error('Invalid Blacklist JSON.'));
+  }
+}
+
+// TODO: Test this impl
+function getBlacklist(cb) {
+  https.get(url, onRequest);
+
+  function onRequest(res) {
+    /* istanbul ignore if */
+    if (res.statusCode !== 200) {
+      // TODO: Test different status codes
+      return cb(new Error('Request failed. Status Code: ' + res.statusCode));
+    }
+
+    res.setEncoding('utf8');
+
+    collect(res, onCollect);
+  }
+
+  function onCollect(err, result) {
+    /* istanbul ignore if */
+    if (err) {
+      return cb(err);
+    }
+
+    parse(result, onParse);
+  }
+
+  function onParse(err, blacklist) {
+    /* istanbul ignore if */
+    if (err) {
+      return cb(err);
+    }
+
+    cb(null, blacklist);
+  }
+}
+
+module.exports = getBlacklist;
--- a/node_modules/gulp-cli/lib/shared/log/blacklist-error.js
+++ b/node_modules/gulp-cli/lib/shared/log/blacklist-error.js
@ -0,0 +1,15 @@
+'use strict';
+
+var log = require('gulplog');
+
+var ansi = require('../ansi');
+var exit = require('../exit');
+
+/* istanbul ignore next */
+function logBlacklistError(err) {
+  log.error(ansi.red('Error: failed to retrieve plugins black-list'));
+  log.error(err.message); // Avoid duplicating for each version
+  exit(1);
+}
+
+module.exports = logBlacklistError;
--- a/node_modules/gulp-cli/lib/shared/log/copy-tree.js
+++ b/node_modules/gulp-cli/lib/shared/log/copy-tree.js
@ -0,0 +1,81 @@
+'use strict';
+
+function copyNode(node) {
+  var newNode = {};
+  Object.keys(node).forEach(function(key) {
+    newNode[key] = node[key];
+  });
+  return newNode;
+}
+
+var defaultNodeFactory = {
+  topNode: copyNode,
+  taskNode: copyNode,
+  childNode: copyNode,
+};
+
+function copyTree(tree, opts, nodeFactory) {
+  opts = opts || {};
+
+  var depth = opts.tasksDepth;
+  depth = typeof depth === 'number' ? ((depth < 1) ? 1 : depth) : null;
+
+  nodeFactory = nodeFactory || defaultNodeFactory;
+
+  var newTree = nodeFactory.topNode(tree);
+  newTree.nodes = [];
+
+  if (Array.isArray(tree.nodes)) {
+    tree.nodes.forEach(visit);
+  }
+
+  function visit(node) {
+    var newNode = nodeFactory.taskNode(node);
+    newNode.nodes = [];
+    newTree.nodes.push(newNode);
+
+    if (opts.compactTasks) {
+      forEach(node.nodes, copyNotRecursively, newNode);
+
+    } else if (!depth || depth > 1) {
+      forEach(node.nodes, copyRecursively, depth, 2, newNode);
+    }
+  }
+
+  function copyNotRecursively(child, newParent) {
+    var newChild = nodeFactory.childNode(child);
+    newChild.nodes = [];
+    newParent.nodes.push(newChild);
+
+    if (child.branch) {
+      forEach(child.nodes, copyNotRecursively, newChild);
+    }
+  }
+
+  function copyRecursively(child, maxDepth, nowDepth, newParent) {
+    var newChild = nodeFactory.childNode(child);
+    newChild.nodes = [];
+    newParent.nodes.push(newChild);
+
+    if (!maxDepth || maxDepth > nowDepth) {
+      forEach(child.nodes, copyRecursively, maxDepth, nowDepth + 1, newChild);
+    }
+  }
+
+  return newTree;
+}
+
+function forEach(nodes, fn) {
+  if (!Array.isArray(nodes)) {
+    return;
+  }
+
+  var args = Array.prototype.slice.call(arguments, 2);
+
+  for (var i = 0, n = nodes.length; i < n; i++) {
+    fn.apply(nodes[i], [nodes[i]].concat(args));
+  }
+}
+
+module.exports = copyTree;
+
--- a/node_modules/gulp-cli/lib/shared/log/tasks.js
+++ b/node_modules/gulp-cli/lib/shared/log/tasks.js
@ -0,0 +1,166 @@
+'use strict';
+
+var archy = require('archy');
+var log = require('gulplog');
+
+var sortBy = require('array-sort');
+var isObject = require('isobject');
+
+var ansi = require('../ansi');
+var copyTree = require('./copy-tree');
+
+function logTasks(tree, opts, getTask) {
+  if (opts.sortTasks) {
+    tree.nodes = sortBy(tree.nodes, 'label');
+  }
+
+  var lineInfos = [];
+  var entryObserver = getLineInfoCollector(lineInfos);
+  var nodeFactory = getNodeFactory(getTask, entryObserver);
+
+  tree = copyTree(tree, opts, nodeFactory);
+  var spacer = getSpacerForLineIndents(tree, lineInfos);
+  var lines = getLinesContainingOnlyBranches(tree);
+
+  log.info(tree.label);
+  printTreeList(lines, spacer, lineInfos);
+}
+
+function getLineInfoCollector(lineInfos) {
+  return {
+    topTask: function(node) {
+      lineInfos.push({
+        name: node.label,
+        desc: node.desc,
+        type: 'top',
+      });
+    },
+    option: function(opt) {
+      lineInfos.push({
+        name: opt.label,
+        desc: opt.desc,
+        type: 'option',
+      });
+    },
+    childTask: function(node) {
+      lineInfos.push({
+        name: node.label,
+        type: 'child',
+      });
+    },
+  };
+}
+
+function getNodeFactory(getTask, entryObserver) {
+  return {
+    topNode: function(node) {
+      return {
+        label: node.label,
+      };
+    },
+
+    taskNode: function(node) {
+      /* istanbul ignore next */
+      var task = getTask(node.label) || {};
+
+      var newNode = {
+        label: node.label,
+        desc: typeof task.description === 'string' ? task.description : '',
+        opts: [],
+      };
+      entryObserver.topTask(newNode);
+
+      if (isObject(task.flags)) {
+        Object.keys(task.flags).sort().forEach(function(flag) {
+          if (flag.length === 0) {
+            return;
+          }
+          /* istanbul ignore next */
+          var opt = {
+            label: flag,
+            desc: typeof task.flags[flag] === 'string' ? task.flags[flag] : '',
+          };
+          entryObserver.option(opt);
+          newNode.opts.push(opt);
+          newNode.label += '\n' + opt.label; // The way of archy for options.
+        });
+      }
+
+      return newNode;
+    },
+
+    childNode: function(node) {
+      var newChild = {
+        label: node.label,
+      };
+      entryObserver.childTask(newChild);
+      newChild.label = ''; // Because don't use child tasks to calc indents.
+
+      return newChild;
+    },
+  };
+}
+
+function getSpacerForLineIndents(tree, lineInfos) {
+  var maxSize = 0;
+  var sizes = [];
+
+  archy(tree)
+    .split('\n')
+    .slice(1, -1)
+    .forEach(function(line, index) {
+      var info = lineInfos[index];
+      if (info.type === 'top' || info.type === 'option') {
+        maxSize = Math.max(maxSize, line.length);
+        sizes.push(line.length);
+      } else {
+        sizes.push(0);
+      }
+    });
+
+  maxSize += 3;
+
+  return function(index) {
+    return Array(maxSize - sizes[index]).join(' ');
+  };
+}
+
+function getLinesContainingOnlyBranches(tree) {
+  tree.nodes.forEach(function(node) {
+    node.label = '';
+    node.opts.forEach(function() {
+      node.label += '\n';
+    });
+  });
+
+  return archy(tree)
+    .split('\n')
+    .slice(1, -1);
+}
+
+function printTreeList(lines, spacer, lineInfos) {
+  lines.forEach(function(branch, index) {
+    var info = lineInfos[index];
+
+    var line = ansi.white(branch);
+
+    if (info.type === 'top') {
+      line += ansi.cyan(info.name);
+      if (info.desc.length > 0) {
+        line += spacer(index) + ansi.white(info.desc);
+      }
+    } else if (info.type === 'option') {
+      line += ansi.magenta(info.name);
+      if (info.desc.length > 0) {
+        line += spacer(index) + ansi.white('…' + info.desc);
+      }
+    } else { // If (info.type === 'child') {
+      line += ansi.white(info.name);
+    }
+
+    log.info(line);
+  });
+}
+
+module.exports = logTasks;
+
--- a/node_modules/gulp-cli/lib/shared/log/to-console.js
+++ b/node_modules/gulp-cli/lib/shared/log/to-console.js
@ -0,0 +1,58 @@
+'use strict';
+
+var fancyLog = require('fancy-log');
+
+/* istanbul ignore next */
+function noop() {}
+
+// The sorting of the levels is
+// significant.
+var levels = [
+  'error', // -L: Logs error events.
+  'warn',  // -LL: Logs warn and error events.
+  'info',  // -LLL: Logs info, warn and error events.
+  'debug', // -LLLL: Logs all log levels.
+];
+
+function cleanup(log) {
+  levels.forEach(removeListeners);
+
+  function removeListeners(level) {
+    if (level === 'error') {
+      log.removeListener(level, noop);
+      log.removeListener(level, fancyLog.error);
+    } else {
+      log.removeListener(level, fancyLog);
+    }
+  }
+}
+
+function toConsole(log, opts) {
+  // Remove previous listeners to enable to call this twice.
+  cleanup(log);
+
+  // Return immediately if logging is
+  // not desired.
+  if (opts.tasksSimple || opts.tasksJson || opts.help || opts.version || opts.silent) {
+    // Keep from crashing process when silent.
+    log.on('error', noop);
+    return;
+  }
+
+  // Default loglevel to info level (3).
+  var loglevel = opts.logLevel || 3;
+
+  levels
+    .filter(function(item, i) {
+      return i < loglevel;
+    })
+    .forEach(function(level) {
+      if (level === 'error') {
+        log.on(level, fancyLog.error);
+      } else {
+        log.on(level, fancyLog);
+      }
+    });
+}
+
+module.exports = toConsole;
--- a/node_modules/gulp-cli/lib/shared/log/verify.js
+++ b/node_modules/gulp-cli/lib/shared/log/verify.js
@ -0,0 +1,28 @@
+'use strict';
+
+var log = require('gulplog');
+
+var ansi = require('../ansi');
+var exit = require('../exit');
+
+function logVerify(blacklisted) {
+  var pluginNames = Object.keys(blacklisted);
+
+  if (!pluginNames.length) {
+    log.info(
+      ansi.green('There are no blacklisted plugins in this project')
+    );
+    exit(0);
+  }
+
+  log.warn(ansi.red('Blacklisted plugins found in this project:'));
+
+  pluginNames.map(function(pluginName) {
+    var reason = blacklisted[pluginName];
+    log.warn(ansi.bgred(pluginName) + ': ' + reason);
+  });
+
+  exit(1);
+}
+
+module.exports = logVerify;
--- a/node_modules/gulp-cli/lib/shared/make-title.js
+++ b/node_modules/gulp-cli/lib/shared/make-title.js
@ -0,0 +1,11 @@
+'use strict';
+
+function makeTitle(cmd, argv) {
+  if (!argv || argv.length === 0) {
+    return cmd;
+  }
+
+  return [cmd].concat(argv).join(' ');
+}
+
+module.exports = makeTitle;
--- a/node_modules/gulp-cli/lib/shared/register-exports.js
+++ b/node_modules/gulp-cli/lib/shared/register-exports.js
@ -0,0 +1,21 @@
+'use strict';
+
+function registerExports(gulpInst, tasks) {
+  var taskNames = Object.keys(tasks);
+
+  if (taskNames.length) {
+    taskNames.forEach(register);
+  }
+
+  function register(taskName) {
+    var task = tasks[taskName];
+
+    if (typeof task !== 'function') {
+      return;
+    }
+
+    gulpInst.task(task.displayName || taskName, task);
+  }
+}
+
+module.exports = registerExports;
--- a/node_modules/gulp-cli/lib/shared/require-or-import.js
+++ b/node_modules/gulp-cli/lib/shared/require-or-import.js
@ -0,0 +1,32 @@
+'use strict';
+
+var pathToFileURL = require('url').pathToFileURL;
+
+var importESM;
+try {
+  // Node.js <10 errors out with a SyntaxError when loading a script that uses import().
+  // So a function is dynamically created to catch the SyntaxError at runtime instead of parsetime.
+  // That way we can keep supporting all Node.js versions all the way back to 0.10.
+  importESM = new Function('id', 'return import(id);');
+} catch (e) {
+  importESM = null;
+}
+
+function requireOrImport(path, callback) {
+  var err = null;
+  var cjs;
+  try {
+    cjs = require(path);
+  } catch (e) {
+    if (pathToFileURL && importESM && e.code === 'ERR_REQUIRE_ESM') {
+      // This is needed on Windows, because import() fails if providing a Windows file path.
+      var url = pathToFileURL(path);
+      importESM(url).then(function(esm) { callback(null, esm); }, callback);
+      return;
+    }
+    err = e;
+  }
+  process.nextTick(function() { callback(err, cjs); });
+}
+
+module.exports = requireOrImport;
--- a/node_modules/gulp-cli/lib/shared/tildify.js
+++ b/node_modules/gulp-cli/lib/shared/tildify.js
@ -0,0 +1,9 @@
+'use strict';
+
+var replaceHomedir = require('replace-homedir');
+
+function tildify(filepath) {
+  return replaceHomedir(filepath, '~');
+}
+
+module.exports = tildify;
--- a/node_modules/gulp-cli/lib/shared/verify-dependencies.js
+++ b/node_modules/gulp-cli/lib/shared/verify-dependencies.js
@ -0,0 +1,25 @@
+'use strict';
+
+var matchdep = require('matchdep');
+
+/**
+ * Given a collection of plugin names verifies this collection against
+ * the blacklist. Returns an object with:
+ * [plugin name]=>[blacklisting reason]
+ * or an empty object if none of the dependencies to check are blacklisted.
+ *
+ * @param pkg - package.json contents
+ * @param blacklist - contents of the blacklist in JSON format
+ */
+function verifyDependencies(pkg, blacklist) {
+  var blacklisted = matchdep
+    .filterAll(Object.keys(blacklist), pkg)
+    .reduce(function(blacklisted, pluginName) {
+      blacklisted[pluginName] = blacklist[pluginName];
+      return blacklisted;
+    }, {});
+
+  return blacklisted;
+}
+
+module.exports = verifyDependencies;
--- a/node_modules/gulp-cli/lib/versioned/^3.7.0/format-error.js
+++ b/node_modules/gulp-cli/lib/versioned/^3.7.0/format-error.js
@ -0,0 +1,23 @@
+'use strict';
+
+// Format orchestrator errors
+function formatError(e) {
+  if (!e.err) {
+    return e.message;
+  }
+
+  // PluginError
+  if (typeof e.err.showStack === 'boolean') {
+    return e.err.toString();
+  }
+
+  // Normal error
+  if (e.err.stack) {
+    return e.err.stack;
+  }
+
+  // Unknown (string, number, etc.)
+  return new Error(String(e.err)).stack;
+}
+
+module.exports = formatError;
--- a/node_modules/gulp-cli/lib/versioned/^3.7.0/index.js
+++ b/node_modules/gulp-cli/lib/versioned/^3.7.0/index.js
@ -0,0 +1,83 @@
+'use strict';
+
+var fs = require('fs');
+
+var log = require('gulplog');
+var stdout = require('mute-stdout');
+
+var taskTree = require('./task-tree');
+var copyTree = require('../../shared/log/copy-tree');
+
+var tildify = require('../../shared/tildify');
+var logTasks = require('../../shared/log/tasks');
+var ansi = require('../../shared/ansi');
+var exit = require('../../shared/exit');
+var logEvents = require('./log/events');
+var logTasksSimple = require('./log/tasks-simple');
+var registerExports = require('../../shared/register-exports');
+var requireOrImport = require('../../shared/require-or-import');
+
+function execute(opts, env, config) {
+  var tasks = opts._;
+  var toRun = tasks.length ? tasks : ['default'];
+
+  if (opts.tasksSimple || opts.tasks || opts.tasksJson) {
+    // Mute stdout if we are listing tasks
+    stdout.mute();
+  }
+
+  // This is what actually loads up the gulpfile
+  requireOrImport(env.configPath, function(err, exported) {
+    // Before import(), if require() failed we got an unhandled exception on the module level.
+    // So console.error() & exit() were added here to mimic the old behavior as close as possible.
+    if (err) {
+      console.error(err);
+      exit(1);
+    }
+
+    log.info('Using gulpfile', ansi.magenta(tildify(env.configPath)));
+
+    var gulpInst = require(env.modulePath);
+    logEvents(gulpInst);
+
+    registerExports(gulpInst, exported);
+
+    // Always unmute stdout after gulpfile is required
+    stdout.unmute();
+
+    var tree;
+    if (opts.tasksSimple) {
+      return logTasksSimple(env, gulpInst);
+    }
+    if (opts.tasks) {
+      tree = taskTree(gulpInst.tasks);
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath));
+      }
+      return logTasks(tree, opts, function(task) {
+        return gulpInst.tasks[task].fn;
+      });
+    }
+    if (opts.tasksJson) {
+      tree = taskTree(gulpInst.tasks);
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + tildify(env.configPath);
+      }
+
+      var output = JSON.stringify(copyTree(tree, opts));
+
+      if (typeof opts.tasksJson === 'boolean') {
+        return console.log(output);
+      }
+
+      return fs.writeFileSync(opts.tasksJson, output, 'utf-8');
+    }
+    gulpInst.start.apply(gulpInst, toRun);
+  });
+}
+
+module.exports = execute;
--- a/node_modules/gulp-cli/lib/versioned/^3.7.0/log/events.js
+++ b/node_modules/gulp-cli/lib/versioned/^3.7.0/log/events.js
@ -0,0 +1,60 @@
+'use strict';
+
+var log = require('gulplog');
+var prettyTime = require('pretty-hrtime');
+
+var ansi = require('../../../shared/ansi');
+var exit = require('../../../shared/exit');
+var formatError = require('../format-error');
+
+// Wire up logging events
+function logEvents(gulpInst) {
+
+  // Exit with 0 or 1
+  var failed = false;
+  process.once('exit', function(code) {
+    if (code === 0 && failed) {
+      exit(1);
+    }
+  });
+
+  // Total hack due to poor error management in orchestrator
+  gulpInst.on('err', function() {
+    failed = true;
+  });
+
+  gulpInst.on('task_start', function(e) {
+    // TODO: batch these
+    // so when 5 tasks start at once it only logs one time with all 5
+    log.info('Starting', '\'' + ansi.cyan(e.task) + '\'...');
+  });
+
+  gulpInst.on('task_stop', function(e) {
+    var time = prettyTime(e.hrDuration);
+    log.info(
+      'Finished', '\'' + ansi.cyan(e.task) + '\'',
+      'after', ansi.magenta(time)
+    );
+  });
+
+  gulpInst.on('task_err', function(e) {
+    var msg = formatError(e);
+    var time = prettyTime(e.hrDuration);
+    log.error(
+      '\'' + ansi.cyan(e.task) + '\'',
+      ansi.red('errored after'),
+      ansi.magenta(time)
+    );
+    log.error(msg);
+  });
+
+  gulpInst.on('task_not_found', function(err) {
+    log.error(
+      ansi.red('Task \'' + err.task + '\' is not in your gulpfile')
+    );
+    log.error('Please check the documentation for proper gulpfile formatting');
+    exit(1);
+  });
+}
+
+module.exports = logEvents;
--- a/node_modules/gulp-cli/lib/versioned/^3.7.0/log/tasks-simple.js
+++ b/node_modules/gulp-cli/lib/versioned/^3.7.0/log/tasks-simple.js
@ -0,0 +1,9 @@
+'use strict';
+
+function logTasksSimple(env, localGulp) {
+  console.log(Object.keys(localGulp.tasks)
+    .join('\n')
+    .trim());
+}
+
+module.exports = logTasksSimple;
--- a/node_modules/gulp-cli/lib/versioned/^3.7.0/task-tree.js
+++ b/node_modules/gulp-cli/lib/versioned/^3.7.0/task-tree.js
@ -0,0 +1,27 @@
+'use strict';
+
+module.exports = function(tasks) {
+  var map = {};
+  var arr = [];
+  Object.keys(tasks).forEach(function(taskname) {
+    var task = {
+      label: taskname,
+      type: 'task',
+      nodes: [],
+    };
+    map[taskname] = task;
+    arr.push(task);
+  });
+  Object.keys(tasks).forEach(function(taskname) {
+    var task = map[taskname];
+    tasks[taskname].dep.forEach(function(childname) {
+      var child = map[childname] || {
+        label: childname,
+        type: 'task',
+        nodes: [],
+      };
+      task.nodes.push(child);
+    });
+  });
+  return { label: 'Tasks', nodes: arr };
+};
--- a/node_modules/gulp-cli/lib/versioned/^4.0.0-alpha.1/index.js
+++ b/node_modules/gulp-cli/lib/versioned/^4.0.0-alpha.1/index.js
@ -0,0 +1,96 @@
+'use strict';
+
+var fs = require('fs');
+
+var log = require('gulplog');
+var stdout = require('mute-stdout');
+
+var ansi = require('../../shared/ansi');
+var exit = require('../../shared/exit');
+var tildify = require('../../shared/tildify');
+
+var logTasks = require('../../shared/log/tasks');
+var logEvents = require('../^4.0.0/log/events');
+var logSyncTask = require('../^4.0.0/log/sync-task');
+var logTasksSimple = require('../^4.0.0/log/tasks-simple');
+var registerExports = require('../../shared/register-exports');
+
+var copyTree = require('../../shared/log/copy-tree');
+var requireOrImport = require('../../shared/require-or-import');
+
+function execute(opts, env, config) {
+
+  var tasks = opts._;
+  var toRun = tasks.length ? tasks : ['default'];
+
+  if (opts.tasksSimple || opts.tasks || opts.tasksJson) {
+    // Mute stdout if we are listing tasks
+    stdout.mute();
+  }
+
+  var gulpInst = require(env.modulePath);
+  logEvents(gulpInst);
+  logSyncTask(gulpInst, opts);
+
+  // This is what actually loads up the gulpfile
+  requireOrImport(env.configPath, function(err, exported) {
+    // Before import(), if require() failed we got an unhandled exception on the module level.
+    // So console.error() & exit() were added here to mimic the old behavior as close as possible.
+    if (err) {
+      console.error(err);
+      exit(1);
+    }
+
+    registerExports(gulpInst, exported);
+
+    // Always unmute stdout after gulpfile is required
+    stdout.unmute();
+
+    var tree;
+    if (opts.tasksSimple) {
+      return logTasksSimple(gulpInst.tree());
+    }
+    if (opts.tasks) {
+      tree = {};
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath));
+      }
+      tree.nodes = gulpInst.tree({ deep: true });
+      return logTasks(tree, opts, function(taskname) {
+        return gulpInst.task(taskname);
+      });
+    }
+    if (opts.tasksJson) {
+      tree = {};
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + tildify(env.configPath);
+      }
+      tree.nodes = gulpInst.tree({ deep: true });
+
+      var output = JSON.stringify(copyTree(tree, opts));
+      if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) {
+        return console.log(output);
+      }
+      return fs.writeFileSync(opts.tasksJson, output, 'utf-8');
+    }
+    try {
+      log.info('Using gulpfile', ansi.magenta(tildify(env.configPath)));
+      var runMethod = opts.series ? 'series' : 'parallel';
+      gulpInst[runMethod](toRun)(function(err) {
+        if (err) {
+          exit(1);
+        }
+      });
+    } catch (err) {
+      log.error(ansi.red(err.message));
+      log.error('To list available tasks, try running: gulp --tasks');
+      exit(1);
+    }
+  });
+}
+
+module.exports = execute;
--- a/node_modules/gulp-cli/lib/versioned/^4.0.0-alpha.2/index.js
+++ b/node_modules/gulp-cli/lib/versioned/^4.0.0-alpha.2/index.js
@ -0,0 +1,96 @@
+'use strict';
+
+var fs = require('fs');
+
+var log = require('gulplog');
+var stdout = require('mute-stdout');
+
+var ansi = require('../../shared/ansi');
+var exit = require('../../shared/exit');
+var tildify = require('../../shared/tildify');
+
+var logTasks = require('../../shared/log/tasks');
+var logEvents = require('../^4.0.0/log/events');
+var logSyncTask = require('../^4.0.0/log/sync-task');
+var logTasksSimple = require('../^4.0.0/log/tasks-simple');
+var registerExports = require('../../shared/register-exports');
+
+var copyTree = require('../../shared/log/copy-tree');
+var getTask = require('../^4.0.0/log/get-task');
+var requireOrImport = require('../../shared/require-or-import');
+
+function execute(opts, env, config) {
+
+  var tasks = opts._;
+  var toRun = tasks.length ? tasks : ['default'];
+
+  if (opts.tasksSimple || opts.tasks || opts.tasksJson) {
+    // Mute stdout if we are listing tasks
+    stdout.mute();
+  }
+
+  var gulpInst = require(env.modulePath);
+  logEvents(gulpInst);
+  logSyncTask(gulpInst, opts);
+
+  // This is what actually loads up the gulpfile
+  requireOrImport(env.configPath, function(err, exported) {
+    // Before import(), if require() failed we got an unhandled exception on the module level.
+    // So console.error() & exit() were added here to mimic the old behavior as close as possible.
+    if (err) {
+      console.error(err);
+      exit(1);
+    }
+
+    registerExports(gulpInst, exported);
+
+    // Always unmute stdout after gulpfile is required
+    stdout.unmute();
+
+    var tree;
+    if (opts.tasksSimple) {
+      tree = gulpInst.tree();
+      return logTasksSimple(tree.nodes);
+    }
+    if (opts.tasks) {
+      tree = gulpInst.tree({ deep: true });
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath));
+      }
+
+      return logTasks(tree, opts, getTask(gulpInst));
+    }
+    if (opts.tasksJson) {
+      tree = gulpInst.tree({ deep: true });
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + tildify(env.configPath);
+      }
+
+      var output = JSON.stringify(copyTree(tree, opts));
+
+      if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) {
+        return console.log(output);
+      }
+      return fs.writeFileSync(opts.tasksJson, output, 'utf-8');
+    }
+    try {
+      log.info('Using gulpfile', ansi.magenta(tildify(env.configPath)));
+      var runMethod = opts.series ? 'series' : 'parallel';
+      gulpInst[runMethod](toRun)(function(err) {
+        if (err) {
+          exit(1);
+        }
+      });
+    } catch (err) {
+      log.error(ansi.red(err.message));
+      log.error('To list available tasks, try running: gulp --tasks');
+      exit(1);
+    }
+  });
+}
+
+module.exports = execute;
--- a/node_modules/gulp-cli/lib/versioned/^4.0.0/format-error.js
+++ b/node_modules/gulp-cli/lib/versioned/^4.0.0/format-error.js
@ -0,0 +1,24 @@
+'use strict';
+
+// Format orchestrator errors
+/* istanbul ignore next */
+function formatError(e) {
+  if (!e.error) {
+    return e.message;
+  }
+
+  // PluginError
+  if (typeof e.error.showStack === 'boolean') {
+    return e.error.toString();
+  }
+
+  // Normal error
+  if (e.error.stack) {
+    return e.error.stack;
+  }
+
+  // Unknown (string, number, etc.)
+  return new Error(String(e.error)).stack;
+}
+
+module.exports = formatError;
--- a/node_modules/gulp-cli/lib/versioned/^4.0.0/index.js
+++ b/node_modules/gulp-cli/lib/versioned/^4.0.0/index.js
@ -0,0 +1,96 @@
+'use strict';
+
+var fs = require('fs');
+
+var log = require('gulplog');
+var stdout = require('mute-stdout');
+
+var ansi = require('../../shared/ansi');
+var exit = require('../../shared/exit');
+var tildify = require('../../shared/tildify');
+
+var logTasks = require('../../shared/log/tasks');
+var logEvents = require('./log/events');
+var logSyncTask = require('./log/sync-task');
+var logTasksSimple = require('./log/tasks-simple');
+var registerExports = require('../../shared/register-exports');
+
+var copyTree = require('../../shared/log/copy-tree');
+var getTask = require('./log/get-task');
+var requireOrImport = require('../../shared/require-or-import');
+
+function execute(opts, env, config) {
+
+  var tasks = opts._;
+  var toRun = tasks.length ? tasks : ['default'];
+
+  if (opts.tasksSimple || opts.tasks || opts.tasksJson) {
+    // Mute stdout if we are listing tasks
+    stdout.mute();
+  }
+
+  var gulpInst = require(env.modulePath);
+  logEvents(gulpInst);
+  logSyncTask(gulpInst, opts);
+
+  // This is what actually loads up the gulpfile
+  requireOrImport(env.configPath, function(err, exported) {
+    // Before import(), if require() failed we got an unhandled exception on the module level.
+    // So console.error() & exit() were added here to mimic the old behavior as close as possible.
+    if (err) {
+      console.error(err);
+      exit(1);
+    }
+
+    registerExports(gulpInst, exported);
+
+    // Always unmute stdout after gulpfile is required
+    stdout.unmute();
+
+    var tree;
+    if (opts.tasksSimple) {
+      tree = gulpInst.tree();
+      return logTasksSimple(tree.nodes);
+    }
+    if (opts.tasks) {
+      tree = gulpInst.tree({ deep: true });
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath));
+      }
+
+      return logTasks(tree, opts, getTask(gulpInst));
+    }
+    if (opts.tasksJson) {
+      tree = gulpInst.tree({ deep: true });
+      if (config.description && typeof config.description === 'string') {
+        tree.label = config.description;
+      } else {
+        tree.label = 'Tasks for ' + tildify(env.configPath);
+      }
+
+      var output = JSON.stringify(copyTree(tree, opts));
+
+      if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) {
+        return console.log(output);
+      }
+      return fs.writeFileSync(opts.tasksJson, output, 'utf-8');
+    }
+    try {
+      log.info('Using gulpfile', ansi.magenta(tildify(env.configPath)));
+      var runMethod = opts.series ? 'series' : 'parallel';
+      gulpInst[runMethod](toRun)(function(err) {
+        if (err) {
+          exit(1);
+        }
+      });
+    } catch (err) {
+      log.error(ansi.red(err.message));
+      log.error('To list available tasks, try running: gulp --tasks');
+      exit(1);
+    }
+  });
+}
+
+module.exports = execute;
--- a/node_modules/gulp-cli/lib/versioned/^4.0.0/log/events.js
+++ b/node_modules/gulp-cli/lib/versioned/^4.0.0/log/events.js
@ -0,0 +1,50 @@
+'use strict';
+
+var log = require('gulplog');
+var prettyTime = require('pretty-hrtime');
+
+var ansi = require('../../../shared/ansi');
+var formatError = require('../format-error');
+
+// Wire up logging events
+function logEvents(gulpInst) {
+
+  var loggedErrors = [];
+
+  gulpInst.on('start', function(evt) {
+    /* istanbul ignore next */
+    // TODO: batch these
+    // so when 5 tasks start at once it only logs one time with all 5
+    var level = evt.branch ? 'debug' : 'info';
+    log[level]('Starting', '\'' + ansi.cyan(evt.name) + '\'...');
+  });
+
+  gulpInst.on('stop', function(evt) {
+    var time = prettyTime(evt.duration);
+    /* istanbul ignore next */
+    var level = evt.branch ? 'debug' : 'info';
+    log[level](
+      'Finished', '\'' + ansi.cyan(evt.name) + '\'',
+      'after', ansi.magenta(time)
+    );
+  });
+
+  gulpInst.on('error', function(evt) {
+    var msg = formatError(evt);
+    var time = prettyTime(evt.duration);
+    var level = evt.branch ? 'debug' : 'error';
+    log[level](
+      '\'' + ansi.cyan(evt.name) + '\'',
+      ansi.red('errored after'),
+      ansi.magenta(time)
+    );
+
+    // If we haven't logged this before, log it and add to list
+    if (loggedErrors.indexOf(evt.error) === -1) {
+      log.error(msg);
+      loggedErrors.push(evt.error);
+    }
+  });
+}
+
+module.exports = logEvents;
--- a/node_modules/gulp-cli/lib/versioned/^4.0.0/log/get-task.js
+++ b/node_modules/gulp-cli/lib/versioned/^4.0.0/log/get-task.js
@ -0,0 +1,43 @@
+'use strict';
+
+var isObject = require('isobject');
+
+function getTask(gulpInst) {
+  return function(name) {
+    var task = gulpInst.task(name);
+    return {
+      description: getDescription(task),
+      flags: getFlags(task),
+    };
+  };
+}
+
+function getDescription(task) {
+  if (typeof task.description === 'string') {
+    return task.description;
+  }
+  /* istanbul ignore else */
+  if (typeof task.unwrap === 'function') {
+    var origFn = task.unwrap();
+    if (typeof origFn.description === 'string') {
+      return origFn.description;
+    }
+  }
+  return undefined;
+}
+
+function getFlags(task) {
+  if (isObject(task.flags)) {
+    return task.flags;
+  }
+  /* istanbul ignore else */
+  if (typeof task.unwrap === 'function') {
+    var origFn = task.unwrap();
+    if (isObject(origFn.flags)) {
+      return origFn.flags;
+    }
+  }
+  return undefined;
+}
+
+module.exports = getTask;
--- a/node_modules/gulp-cli/lib/versioned/^4.0.0/log/sync-task.js
+++ b/node_modules/gulp-cli/lib/versioned/^4.0.0/log/sync-task.js
@ -0,0 +1,52 @@
+'use strict';
+
+var log = require('gulplog');
+var ansi = require('../../../shared/ansi');
+
+var tasks = {};
+
+function warn() {
+  var taskKeys = Object.keys(tasks);
+
+  if (!taskKeys.length) {
+    return;
+  }
+
+  var taskNames = taskKeys.map(function(key) {
+    return tasks[key];
+  }).join(', ');
+
+  process.exitCode = 1;
+
+  log.warn(
+    ansi.red('The following tasks did not complete:'),
+    ansi.cyan(taskNames)
+  );
+  log.warn(
+    ansi.red('Did you forget to signal async completion?')
+  );
+}
+
+function start(e) {
+  tasks[e.uid] = e.name;
+}
+
+function clear(e) {
+  delete tasks[e.uid];
+}
+
+function clearAll() {
+  tasks = {};
+}
+
+function logSyncTask(gulpInst, opts) {
+
+  process.once('exit', warn);
+  gulpInst.on('start', start);
+  gulpInst.on('stop', clear);
+  // When not running in --continue mode, we need to clear everything on error to avoid
+  // false positives.
+  gulpInst.on('error', opts.continue ? clear : clearAll);
+}
+
+module.exports = logSyncTask;
--- a/node_modules/gulp-cli/lib/versioned/^4.0.0/log/tasks-simple.js
+++ b/node_modules/gulp-cli/lib/versioned/^4.0.0/log/tasks-simple.js
@ -0,0 +1,7 @@
+'use strict';
+
+function logTasksSimple(nodes) {
+  console.log(nodes.join('\n').trim());
+}
+
+module.exports = logTasksSimple;
--- a/node_modules/gulp-cli/package.json
+++ b/node_modules/gulp-cli/package.json
@ -0,0 +1,77 @@
+{
+  "name": "gulp-cli",
+  "version": "2.3.0",
+  "description": "Command line interface for gulp",
+  "author": "Gulp Team <team@gulpjs.com> (https://gulpjs.com/)",
+  "contributors": [],
+  "homepage": "https://gulpjs.com",
+  "repository": "gulpjs/gulp-cli",
+  "license": "MIT",
+  "man": "gulp.1",
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "main": "index.js",
+  "bin": {
+    "gulp": "bin/gulp.js"
+  },
+  "files": [
+    "index.js",
+    "lib",
+    "bin",
+    "completion",
+    "gulp.1"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "prepublish": "marked-man --name gulp docs/CLI.md > gulp.1",
+    "pretest": "npm run lint",
+    "test": "mocha --async-only --timeout 5000 test/lib test",
+    "cover": "nyc --reporter=lcov --reporter=text-summary npm test",
+    "coveralls": "nyc --reporter=text-lcov npm test | coveralls"
+  },
+  "dependencies": {
+    "ansi-colors": "^1.0.1",
+    "archy": "^1.0.0",
+    "array-sort": "^1.0.0",
+    "concat-stream": "^1.6.0",
+    "color-support": "^1.1.3",
+    "copy-props": "^2.0.1",
+    "fancy-log": "^1.3.2",
+    "gulplog": "^1.0.0",
+    "interpret": "^1.4.0",
+    "isobject": "^3.0.1",
+    "liftoff": "^3.1.0",
+    "matchdep": "^2.0.0",
+    "mute-stdout": "^1.0.0",
+    "pretty-hrtime": "^1.0.0",
+    "replace-homedir": "^1.0.0",
+    "semver-greatest-satisfied-range": "^1.1.0",
+    "v8flags": "^3.2.0",
+    "yargs": "^7.1.0"
+  },
+  "devDependencies": {
+    "babel-preset-es2015": "^6.5.0",
+    "babel-register": "^6.5.1",
+    "coveralls": "^3.0.3",
+    "eslint": "^2.13.1",
+    "eslint-config-gulp": "^3.0.1",
+    "expect": "^1.20.2",
+    "gulp": "^4.0.0",
+    "gulp-test-tools": "^0.6.1",
+    "marked-man": "^0.2.1",
+    "mocha": "^3.2.0",
+    "nyc": "^13.3.0",
+    "rimraf": "^2.6.1",
+    "semver": "^5.7.1"
+  },
+  "keywords": [
+    "build",
+    "stream",
+    "system",
+    "make",
+    "tool",
+    "asset",
+    "pipeline"
+  ]
+}