Added vendor directory & gulp support for better dependency organization + compiling less & js files. added gulp

support for a browser sync task as well for easier development

node_modules/gulp-uglify/CHANGELOG.md

@@ -0,0 +1,95 @@
+As of version 2.0.0, the CHANGELOG is maintained on [GitHub Releases](https://github.com/terinjokes/gulp-uglify/releases).
+
+# Change Log
+
+<a name="1.5.4"></a>
+## [1.5.4](https://github.com/terinjokes/gulp-uglify/compare/v1.5.3...v1.5.4) (2016-06-22)
+
+## 1.5.3
+
+- Updated UglifyJS to 2.6.2
+
+## 1.5.2
+
+- Updated UglfiyJS to 2.6.1
+
+## 1.5.0
+
+- Update UglifyJS to 2.6.0.
+- CI and dependencies chores.
+- Attempt to resolve issue #109 where "ghost" files would appear in generated sourcemaps.
+
+## 1.4.2
+
+- Updated UglifyJS to 2.5.0.
+- CI and dependencies chores.
+
+## 1.4.1
+
+- Detect if options is a non-Object and log a warning.
+
+  Older versions of Node.js did not allow Strings to be passed to `Object.keys` leading to errors and confusion to users following certain tutorials.
+
+## 1.4.0
+
+- Deprecated the `preserveComments` option of "some".
+- Added the `preserveComments` option of "license" that uses [`uglify-save-license`](https://github.com/shinnn/uglify-save-license).
+
+## 1.3.0
+
+- Updated UglifyJS to 2.4.24.
+- Streams3 support via through2 dependency update.
+
+## 1.2.0
+
+- Update dependencies, including UglifyJS to 2.4.19.
+
+## 1.1.0
+
+- Fix sources path in source maps (thanks @floridoo)
+- Update UglifyJS to 2.4.16 (thanks @tschaub)
+
+## 1.0.0
+
+- Handle cases where UglifyJS uses e.msg instead of e.message for error codes. Fixes #51.
+- Supplement UglifyJS’s source map merging with vinyl-sourcemap-apply to correct issues where `sources` and `sourcesContent` were different. Fixes #43.
+- Refactor option parsing and defaults, and calls to uglify-js, to reduce complexity of the main function.
+- Added tests for the previously forgotten `preserveComments` option.
+- Updated UglifyJS to 2.4.15.
+- Changed dependencies to explicit ranges to avoid `node-semver` issues.
+
+## 0.3.2
+
+- Removed the PluginError factory wrapper
+- Removed test that was failing due to gulp-util issue.
+- Tests should end the streams they are writing to.
+- Update dependencies. Fixes #44. Fixes #42.
+
+## 0.3.1
+
+- Fixed homepage URL in npm metadata
+- Removes UglifyJS-inserted sourceMappingURL comment [Fixes #39]
+- Don’t pass input source map to UglifyJS if there are no mappings
+- Added installation instructions
+
+## 0.3.0
+
+- Removed support for old style source maps
+- Added support for gulp-sourcemap
+- Updated tape development dependency
+- Dropped support for Node 0.9
+- UglifyJS errors are no longer swallowed
+
+## 0.2.1
+
+- Correct source map output
+- Remove `gulp` dependency by using `vinyl` in testing
+- Passthrough null files correctly
+- Report error if attempting to use a stream-backed file
+
+## 0.2.0
+
+- Dropped support for Node versions less than 0.9
+- Switched to using Streams2
+- Add support for generating source maps
+- Add option for preserving comments

node_modules/gulp-uglify/LICENSE.md

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

node_modules/gulp-uglify/README.md

@@ -0,0 +1,95 @@
+# gulp-uglify [![][travis-shield-img]][travis-shield][![][appveyor-shield-img]][appveyor-shield][![][npm-dl-shield-img]][npm-shield][![][npm-v-shield-img]][npm-shield][![][coveralls-shield-img]][coveralls-shield]
+
+> Minify JavaScript with UglifyJS2.
+
+## Installation
+
+Install package with NPM and add it to your development dependencies:
+
+`npm install --save-dev gulp-uglify`
+
+## Usage
+
+```javascript
+var gulp = require('gulp');
+var uglify = require('gulp-uglify');
+var pump = require('pump');
+
+gulp.task('compress', function (cb) {
+  pump([
+        gulp.src('lib/*.js'),
+        uglify(),
+        gulp.dest('dist')
+    ],
+    cb
+  );
+});
+```
+
+To help properly handle error conditions with Node streams, this project
+recommends the use of [`pump`](https://github.com/mafintosh/pump). For more
+information, see [Why Use Pump?](docs/why-use-pump/README.md#why-use-pump).
+
+## Options
+
+Most of the [minify options](https://github.com/mishoo/UglifyJS2#minify-options) from
+the UglifyJS API are supported. There are a few exceptions:
+
+1. The `sourceMap` option must not be set, as it will be automatically configured
+   based on your Gulp configuration. See the documentation for [Gulp sourcemaps][gulp-sm].
+
+[gulp-sm]: https://github.com/gulp-sourcemaps/gulp-sourcemaps#usage
+
+## Errors
+
+`gulp-uglify` emits an 'error' event if it is unable to minify a specific file.
+The GulpUglifyError constructor is exported by this plugin for `instanceof` checks.
+It contains the following properties:
+
+- `fileName`: The full file path for the file being minified.
+- `cause`: The original UglifyJS error, if available.
+
+Most UglifyJS error messages have the following properties:
+
+- `message` (or `msg`)
+- `filename`
+- `line`
+
+To see useful error messages, see [Why Use Pump?](docs/why-use-pump/README.md#why-use-pump).
+
+## Using a Different UglifyJS
+
+By default, `gulp-uglify` uses the version of UglifyJS installed as a dependency.
+It's possible to configure the use of a different version using the "composer" entry point.
+
+```javascript
+var uglifyjs = require('uglify-js'); // can be a git checkout
+                                     // or another module (such as `uglify-es` for ES6 support)
+var composer = require('gulp-uglify/composer');
+var pump = require('pump');
+
+var minify = composer(uglifyjs, console);
+
+gulp.task('compress', function (cb) {
+  // the same options as described above
+  var options = {};
+
+  pump([
+      gulp.src('lib/*.js'),
+      minify(options),
+      gulp.dest('dist')
+    ],
+    cb
+  );
+});
+```
+
+[travis-shield-img]: https://img.shields.io/travis/terinjokes/gulp-uglify/master.svg?label=Travis%20CI&style=flat-square
+[travis-shield]: https://travis-ci.org/terinjokes/gulp-uglify
+[appveyor-shield-img]: https://img.shields.io/appveyor/ci/terinjokes/gulp-uglify/master.svg?label=AppVeyor&style=flat-square
+[appveyor-shield]: https://ci.appveyor.com/project/terinjokes/gulp-uglify
+[npm-dl-shield-img]: https://img.shields.io/npm/dm/gulp-uglify.svg?style=flat-square
+[npm-shield]: http://browsenpm.org/package/gulp-uglify
+[npm-v-shield-img]: https://img.shields.io/npm/v/gulp-uglify.svg?style=flat-square
+[coveralls-shield-img]: https://img.shields.io/coveralls/terinjokes/gulp-uglify/master.svg?style=flat-square
+[coveralls-shield]: https://coveralls.io/github/terinjokes/gulp-uglify

node_modules/gulp-uglify/composer.js

@@ -0,0 +1,17 @@
+'use strict';
+var through = require('through2');
+var minify = require('./lib/minify');
+
+module.exports = function(uglify, logger) {
+  return function(opts) {
+    var minifier = minify(uglify, logger)(opts);
+    return through.obj(function(file, encoding, callback) {
+      try {
+        var newFile = minifier(file);
+        callback(null, newFile);
+      } catch (err) {
+        callback(err);
+      }
+    });
+  };
+};

node_modules/gulp-uglify/index.js

@@ -0,0 +1,11 @@
+'use strict';
+var uglify = require('uglify-js');
+var compose = require('./composer');
+var GulpUglifyError = require('./lib/gulp-uglify-error');
+var logger = require('./lib/log');
+
+module.exports = function(opts) {
+  return compose(uglify, logger)(opts);
+};
+
+module.exports.GulpUglifyError = GulpUglifyError;

node_modules/gulp-uglify/lib/create-error.js

@@ -0,0 +1,13 @@
+'use strict';
+var curry = require('lodash/fp/curry');
+var GulpUglifyError = require('./gulp-uglify-error');
+
+function createError(file, msg, cause) {
+  var perr = new GulpUglifyError(msg, cause);
+  perr.plugin = 'gulp-uglify';
+  perr.fileName = file.path;
+  perr.showStack = false;
+  return perr;
+}
+
+module.exports = curry(createError);

node_modules/gulp-uglify/lib/gulp-uglify-error.js

@@ -0,0 +1,15 @@
+'use strict';
+var makeErrorCause = require('make-error-cause');
+
+var gulpUglifyError = makeErrorCause('GulpUglifyError');
+gulpUglifyError.prototype.toString = function() {
+  var cause = this.cause || {};
+
+  return (
+    makeErrorCause.BaseError.prototype.toString.call(this) +
+    (this.fileName ? '\nFile: ' + this.fileName : '') +
+    (cause.line ? '\nLine: ' + cause.line : '')
+  );
+};
+
+module.exports = gulpUglifyError;

node_modules/gulp-uglify/lib/log.js

@@ -0,0 +1,15 @@
+'use strict';
+var hasLog = require('has-gulplog');
+var each = require('lodash/fp/forEach');
+
+var levels = ['debug', 'info', 'warn', 'error'];
+
+each(function(level) {
+  module.exports[level] = function() {
+    if (hasLog()) {
+      var log = require('gulplog');
+
+      log[level].apply(log, arguments);
+    }
+  };
+}, levels);

node_modules/gulp-uglify/lib/minify.js

@@ -0,0 +1,77 @@
+'use strict';
+var applySourceMap = require('vinyl-sourcemaps-apply');
+var isObject = require('lodash/fp/isObject');
+var defaultsDeep = require('lodash/fp/defaultsDeep');
+var createError = require('./create-error');
+
+module.exports = function(uglify, log) {
+  function setup(opts) {
+    if (opts && !isObject(opts)) {
+      log.warn('gulp-uglify expects an object, non-object provided');
+      opts = {};
+    }
+
+    return defaultsDeep(
+      {
+        output: {}
+      },
+      opts
+    );
+  }
+
+  return function(opts) {
+    return function(file) {
+      var options = setup(opts || {});
+      var hasSourceMaps = Boolean(file.sourceMap);
+
+      if (file.isNull()) {
+        return file;
+      }
+
+      if (file.isStream()) {
+        throw createError(file, 'Streaming not supported', null);
+      }
+
+      if (hasSourceMaps) {
+        options.sourceMap = {
+          filename: file.sourceMap.file,
+          includeSources: true
+        };
+
+        // UglifyJS generates broken source maps if the input source map
+        // does not contain mappings.
+        if (file.sourceMap.mappings) {
+          options.sourceMap.content = file.sourceMap;
+        }
+      }
+
+      var fileMap = {};
+      fileMap[file.relative] = String(file.contents);
+
+      var mangled = uglify.minify(fileMap, options);
+
+      if (!mangled || mangled.error) {
+        throw createError(
+          file,
+          'unable to minify JavaScript',
+          mangled && mangled.error
+        );
+      }
+
+      if (mangled.warnings) {
+        mangled.warnings.forEach(function(warning) {
+          log.warn('gulp-uglify [%s]: %s', file.relative, warning);
+        });
+      }
+
+      file.contents = new Buffer(mangled.code);
+
+      if (hasSourceMaps) {
+        var sourceMap = JSON.parse(mangled.map);
+        applySourceMap(file, sourceMap);
+      }
+
+      return file;
+    };
+  };
+};

node_modules/gulp-uglify/node_modules/.bin/uglifyjs

@@ -0,0 +1 @@
+../uglify-js/bin/uglifyjs

node_modules/gulp-uglify/node_modules/gulplog/CHANGELOG.md

@@ -0,0 +1,10 @@
+# gulplog changelog
+
+## 1.0.0
+
+- Initial release
+- No implementation changed since initial commit
+
+## 0.0.0
+
+- Experimentation

node_modules/gulp-uglify/node_modules/gulplog/LICENSE

@@ -0,0 +1,22 @@
+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.
+

node_modules/gulp-uglify/node_modules/gulplog/README.md

@@ -0,0 +1,79 @@
+<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>
+
+# gulplog
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][travis-image]][travis-url] [![Gitter chat][gitter-image]][gitter-url]
+
+Logger for gulp and gulp plugins
+
+## Usage
+
+```js
+var logger = require('gulplog');
+
+// logs strings
+logger.debug('The MOST verbose!');
+logger.info('Some important info');
+logger.warn('All the warnings to you');
+logger.error('OH NO! SOMETHING HAPPENED!');
+
+// supports util.format!
+logger.info('%s style!', 'printf');
+
+// log anything
+logger.debug({ my: 'obj' });
+logger.info([1, 2, 3]);
+```
+
+## API
+
+Logging (and level of logging) is controlled by [`gulp-cli`][gulp-cli-url]
+
+#### logger.debug(msg)
+
+Highest log level.  Typically used for debugging purposes.
+
+If the first argument is a string, all arguments are passed to node's
+[`util.format()`][util-format-url] before being emitted.
+
+#### logger.info(msg)
+
+Standard log level.  Typically used for user information.
+
+If the first argument is a string, all arguments are passed to node's
+[`util.format()`][util-format-url] before being emitted.
+
+#### logger.warn(msg)
+
+Warning log level.  Typically used for warnings.
+
+If the first argument is a string, all arguments are passed to node's
+[`util.format()`][util-format-url] before being emitted.
+
+#### logger.error(msg)
+
+Error log level.  Typically used when things went horribly wrong.
+
+If the first argument is a string, all arguments are passed to node's
+[`util.format()`][util-format-url] before being emitted.
+
+## License
+
+MIT
+
+[downloads-image]: http://img.shields.io/npm/dm/gulplog.svg
+[npm-url]: https://npmjs.org/package/gulplog
+[npm-image]: http://img.shields.io/npm/v/gulplog.svg
+
+[travis-url]: https://travis-ci.org/gulpjs/gulplog
+[travis-image]: http://img.shields.io/travis/gulpjs/gulplog.svg
+
+[gitter-url]: https://gitter.im/gulpjs/gulp
+[gitter-image]: https://badges.gitter.im/gulpjs/gulp.png
+
+[gulp-cli-url]: https://github.com/gulpjs/gulp-cli
+[util-format-url]: https://nodejs.org/docs/latest/api/util.html#util_util_format_format

node_modules/gulp-uglify/node_modules/gulplog/index.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var getLogger = require('glogg');
+
+var logger = getLogger('gulplog');
+
+module.exports = logger;

node_modules/gulp-uglify/node_modules/gulplog/node_modules/glogg/LICENSE

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

node_modules/gulp-uglify/node_modules/gulplog/node_modules/glogg/README.md

@@ -0,0 +1,92 @@
+# glogg
+
+[![Travis Build Status](https://img.shields.io/travis/js-cli/glogg/master.svg?label=travis&style=flat-square)](https://travis-ci.org/js-cli/glogg)
+
+Global logging utility
+
+## Usage
+
+```js
+var getLogger = require('glogg');
+
+var logger = getLogger('my-namespace');
+
+// logs strings
+logger.debug('The MOST verbose!');
+logger.info('Some important info');
+logger.warn('All the warnings to you');
+logger.error('OH NO! SOMETHING HAPPENED!');
+
+// supports util.format!
+logger.info('%s style!', 'printf');
+
+// log anything
+logger.debug({ my: 'obj' });
+logger.info([1, 2, 3]);
+
+// somewhere else
+logger.on('info', function(msg){
+  // do something with msg
+});
+
+// must be handled to avoid crashing process
+logger.on('error', function(msg){
+  // now it won't crash
+});
+```
+
+## API
+
+__Note: This module makes no assumptions about the log levels and they will always
+be emitted.  If you are looking to filter some out, your listeners will need to have
+extra logic.__
+
+### getLogger([namespace])
+
+Create a new logger at the given namespace (or the default if no namespace is provided).
+Returns an augmented [`sparkles`](https://github.com/phated/sparkles) EventEmitter object
+with 4 methods: `debug()`, `info()`, `warn()` and `error()`. When called, these methods emit
+an event with the same name.  If the first argument is a string, the arguments
+are passed through node's `util.format()` before being emitted.  Other parts
+of a node program can get the logger by namespace and listen for the events to
+be emitted.
+
+#### logger.debug(msg)
+
+Emits a `debug` event with the given `msg`.
+
+If the first argument is a string, all arguments are passed to node's
+`util.format()` before being emitted.
+
+#### logger.info(msg)
+
+Emits a `info` event with the given `msg`.
+
+If the first argument is a string, all arguments are passed to node's
+`util.format()` before being emitted.
+
+#### logger.warn(msg)
+
+Emits a `warn` event with the given `msg`.
+
+If the first argument is a string, all arguments are passed to node's
+`util.format()` before being emitted.
+
+#### logger.error(msg)
+
+Emits a `error` event with the given `msg`.
+
+If the first argument is a string, all arguments are passed to node's
+`util.format()` before being emitted.
+
+__Note: You must handle this event in some way or the node process will crash
+when an `error` event is emitted.__
+
+#### logger.on(event, fn)
+
+Standard API from node's `EventEmitter`.  Use this to listen for events from
+the logger methods.
+
+## License
+
+MIT

node_modules/gulp-uglify/node_modules/gulplog/node_modules/glogg/index.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var format = require('util').format;
+
+var sparkles = require('sparkles');
+
+var levels = [
+  'debug',
+  'info',
+  'warn',
+  'error'
+];
+
+function getLogger(namespace) {
+  var logger = sparkles(namespace);
+
+  levels.forEach(function(level){
+    logger[level] = makeLogLevel(logger, level);
+  });
+
+  return logger;
+}
+
+function makeLogLevel(self, level) {
+  return function(msg){
+    if (typeof msg === 'string') {
+      msg = format.apply(null, arguments);
+    }
+
+    self.emit(level, msg);
+  };
+}
+
+module.exports = getLogger;

node_modules/gulp-uglify/node_modules/gulplog/node_modules/glogg/node_modules/sparkles/LICENSE

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

node_modules/gulp-uglify/node_modules/gulplog/node_modules/glogg/node_modules/sparkles/README.md

@@ -0,0 +1,41 @@
+sparkles
+========
+
+[![Build Status](https://travis-ci.org/phated/sparkles.svg?branch=master)](https://travis-ci.org/phated/sparkles)
+
+Namespaced global event emitter
+
+## Usage
+
+Sparkles exports a function that returns a singleton `EventEmitter`.
+This EE can be shared across your application, whether or not node loads
+multiple copies.
+
+```js
+var sparkles = require('sparkles')(); // make sure to call the function
+
+sparkles.on('my-event', function(evt){
+  console.log('my-event handled', evt);
+});
+
+sparkles.emit('my-event', { my: 'event' });
+```
+
+## API
+
+### sparkles(namespace)
+
+Returns an EventEmitter that is shared amongst the provided namespace.  If no namespace
+is provided, returns a default EventEmitter.
+
+### sparkles.exists(namespace);
+
+Checks whether a namespace exists and returns true or false.
+
+## Why the name?
+
+This is a "global emitter"; shortened: "glitter" but it was already taken; so we got sparkles instead :smile:
+
+## License
+
+MIT

node_modules/gulp-uglify/node_modules/gulplog/node_modules/glogg/node_modules/sparkles/index.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var EventEmitter = require('events').EventEmitter;
+
+var sparklesNamespace = 'store@sparkles';
+var defaultNamespace = 'default';
+
+function getStore(){
+  var store = global[sparklesNamespace];
+
+  if(!store){
+    store = global[sparklesNamespace] = {};
+  }
+
+  return store;
+}
+
+function getEmitter(namespace){
+
+  var store = getStore();
+
+  namespace = namespace || defaultNamespace;
+
+  var ee = store[namespace];
+
+  if(!ee){
+    ee = store[namespace] = new EventEmitter();
+    ee.setMaxListeners(0);
+    ee.remove = function remove(){
+      ee.removeAllListeners();
+      delete store[namespace];
+    };
+  }
+
+  return ee;
+}
+
+function exists(namespace){
+  var store = getStore();
+
+  return !!(store[namespace]);
+}
+
+module.exports = getEmitter;
+module.exports.exists = exists;

node_modules/gulp-uglify/node_modules/gulplog/node_modules/glogg/node_modules/sparkles/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "sparkles",
+  "version": "1.0.0",
+  "description": "Namespaced global event emitter",
+  "author": {
+    "name": "Blaine Bublitz",
+    "email": "blaine@iceddev.com",
+    "url": "http://iceddev.com/"
+  },
+  "contributors": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phated/sparkles.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "main": "index.js",
+  "files": [
+    "LICENSE",
+    "index.js"
+  ],
+  "scripts": {
+    "test": "lab -cvL --ignore store@sparkles"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@phated/eslint-config-iceddev": "^0.2.1",
+    "code": "^1.5.0",
+    "eslint": "^1.3.1",
+    "eslint-plugin-mocha": "^0.5.1",
+    "eslint-plugin-react": "^3.3.1",
+    "lab": "^5.16.0"
+  },
+  "keywords": [
+    "ee",
+    "emitter",
+    "events",
+    "global",
+    "namespaced"
+  ],
+  "gitHead": "66eed55eeac9f3ba641d4643c5ad2ed598bc6a72",
+  "bugs": {
+    "url": "https://github.com/phated/sparkles/issues"
+  },
+  "homepage": "https://github.com/phated/sparkles#readme",
+  "_id": "sparkles@1.0.0",
+  "_shasum": "1acbbfb592436d10bbe8f785b7cc6f82815012c3",
+  "_from": "sparkles@>=1.0.0 <2.0.0",
+  "_npmVersion": "2.8.3",
+  "_nodeVersion": "0.10.36",
+  "_npmUser": {
+    "name": "phated",
+    "email": "blaine@iceddev.com"
+  },
+  "maintainers": [
+    {
+      "name": "phated",
+      "email": "blaine@iceddev.com"
+    }
+  ],
+  "dist": {
+    "shasum": "1acbbfb592436d10bbe8f785b7cc6f82815012c3",
+    "tarball": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.0.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

node_modules/gulp-uglify/node_modules/gulplog/node_modules/glogg/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "glogg",
+  "version": "1.0.1",
+  "description": "Global logging utility",
+  "author": {
+    "name": "Blaine Bublitz",
+    "email": "blaine@iceddev.com",
+    "url": "http://iceddev.com/"
+  },
+  "contributors": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/js-cli/glogg.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "main": "index.js",
+  "files": [
+    "LICENSE",
+    "index.js"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "pretest": "npm run lint",
+    "test": "mocha --async-only"
+  },
+  "dependencies": {
+    "sparkles": "^1.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^1.7.3",
+    "eslint-config-gulp": "^2.1.0",
+    "expect": "^1.20.2",
+    "mocha": "^2.5.3"
+  },
+  "keywords": [
+    "global",
+    "log",
+    "logger",
+    "logging",
+    "shared"
+  ],
+  "gitHead": "7def97d04e23a7f2f55bdf310212f28bfde09098",
+  "bugs": {
+    "url": "https://github.com/js-cli/glogg/issues"
+  },
+  "homepage": "https://github.com/js-cli/glogg#readme",
+  "_id": "glogg@1.0.1",
+  "_npmVersion": "5.6.0",
+  "_nodeVersion": "8.9.4",
+  "_npmUser": {
+    "name": "phated",
+    "email": "blaine.bublitz@gmail.com"
+  },
+  "dist": {
+    "integrity": "sha512-ynYqXLoluBKf9XGR1gA59yEJisIL7YHEH4xr3ZziHB5/yl4qWfaK8Js9jGe6gBGCSCKVqiyO30WnRZADvemUNw==",
+    "shasum": "dcf758e44789cc3f3d32c1f3562a3676e6a34810",
+    "tarball": "https://registry.npmjs.org/glogg/-/glogg-1.0.1.tgz"
+  },
+  "maintainers": [
+    {
+      "name": "phated",
+      "email": "blaine@iceddev.com"
+    }
+  ],
+  "_npmOperationalInternal": {
+    "host": "s3://npm-registry-packages",
+    "tmp": "tmp/glogg-1.0.1.tgz_1516747557172_0.19143295707181096"
+  },
+  "directories": {},
+  "_shasum": "dcf758e44789cc3f3d32c1f3562a3676e6a34810",
+  "_resolved": "https://registry.npmjs.org/glogg/-/glogg-1.0.1.tgz",
+  "_from": "glogg@>=1.0.0 <2.0.0",
+  "readme": "ERROR: No README data found!"
+}

node_modules/gulp-uglify/node_modules/gulplog/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "gulplog",
+  "version": "1.0.0",
+  "description": "Logger for gulp and gulp plugins",
+  "author": {
+    "name": "Blaine Bublitz",
+    "email": "blaine@iceddev.com",
+    "url": "http://iceddev.com"
+  },
+  "contributors": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gulpjs/gulplog.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "main": "index.js",
+  "files": [
+    "LICENSE",
+    "index.js"
+  ],
+  "scripts": {
+    "test": "eslint index.js && jscs index.js"
+  },
+  "dependencies": {
+    "glogg": "^1.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^1.5.1",
+    "eslint-config-node-style-guide": "^1.0.1",
+    "jscs": "^2.1.1"
+  },
+  "keywords": [
+    "gulp",
+    "gulp-util",
+    "log",
+    "logging"
+  ],
+  "gitHead": "c920ad89da5a8f3724d35c83b6cbd8e132dada2b",
+  "bugs": {
+    "url": "https://github.com/gulpjs/gulplog/issues"
+  },
+  "homepage": "https://github.com/gulpjs/gulplog#readme",
+  "_id": "gulplog@1.0.0",
+  "_shasum": "e28c4d45d05ecbbed818363ce8f9c5926229ffe5",
+  "_from": "gulplog@>=1.0.0 <2.0.0",
+  "_npmVersion": "2.14.3",
+  "_nodeVersion": "0.10.36",
+  "_npmUser": {
+    "name": "phated",
+    "email": "blaine@iceddev.com"
+  },
+  "maintainers": [
+    {
+      "name": "phated",
+      "email": "blaine@iceddev.com"
+    }
+  ],
+  "dist": {
+    "shasum": "e28c4d45d05ecbbed818363ce8f9c5926229ffe5",
+    "tarball": "https://registry.npmjs.org/gulplog/-/gulplog-1.0.0.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/gulplog/-/gulplog-1.0.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

node_modules/gulp-uglify/node_modules/has-gulplog/LICENSE

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

node_modules/gulp-uglify/node_modules/has-gulplog/README.md

@@ -0,0 +1,2 @@
+# has-gulplog
+Check if gulplog is available before attempting to use it

node_modules/gulp-uglify/node_modules/has-gulplog/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var sparkles = require('sparkles');
+
+function hasGulplog(){
+  return sparkles.exists('gulplog');
+}
+
+module.exports = hasGulplog;

node_modules/gulp-uglify/node_modules/has-gulplog/node_modules/sparkles/LICENSE

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

node_modules/gulp-uglify/node_modules/has-gulplog/node_modules/sparkles/README.md

@@ -0,0 +1,41 @@
+sparkles
+========
+
+[![Build Status](https://travis-ci.org/phated/sparkles.svg?branch=master)](https://travis-ci.org/phated/sparkles)
+
+Namespaced global event emitter
+
+## Usage
+
+Sparkles exports a function that returns a singleton `EventEmitter`.
+This EE can be shared across your application, whether or not node loads
+multiple copies.
+
+```js
+var sparkles = require('sparkles')(); // make sure to call the function
+
+sparkles.on('my-event', function(evt){
+  console.log('my-event handled', evt);
+});
+
+sparkles.emit('my-event', { my: 'event' });
+```
+
+## API
+
+### sparkles(namespace)
+
+Returns an EventEmitter that is shared amongst the provided namespace.  If no namespace
+is provided, returns a default EventEmitter.
+
+### sparkles.exists(namespace);
+
+Checks whether a namespace exists and returns true or false.
+
+## Why the name?
+
+This is a "global emitter"; shortened: "glitter" but it was already taken; so we got sparkles instead :smile:
+
+## License
+
+MIT

node_modules/gulp-uglify/node_modules/has-gulplog/node_modules/sparkles/index.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var EventEmitter = require('events').EventEmitter;
+
+var sparklesNamespace = 'store@sparkles';
+var defaultNamespace = 'default';
+
+function getStore(){
+  var store = global[sparklesNamespace];
+
+  if(!store){
+    store = global[sparklesNamespace] = {};
+  }
+
+  return store;
+}
+
+function getEmitter(namespace){
+
+  var store = getStore();
+
+  namespace = namespace || defaultNamespace;
+
+  var ee = store[namespace];
+
+  if(!ee){
+    ee = store[namespace] = new EventEmitter();
+    ee.setMaxListeners(0);
+    ee.remove = function remove(){
+      ee.removeAllListeners();
+      delete store[namespace];
+    };
+  }
+
+  return ee;
+}
+
+function exists(namespace){
+  var store = getStore();
+
+  return !!(store[namespace]);
+}
+
+module.exports = getEmitter;
+module.exports.exists = exists;

node_modules/gulp-uglify/node_modules/has-gulplog/node_modules/sparkles/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "sparkles",
+  "version": "1.0.0",
+  "description": "Namespaced global event emitter",
+  "author": {
+    "name": "Blaine Bublitz",
+    "email": "blaine@iceddev.com",
+    "url": "http://iceddev.com/"
+  },
+  "contributors": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/phated/sparkles.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "main": "index.js",
+  "files": [
+    "LICENSE",
+    "index.js"
+  ],
+  "scripts": {
+    "test": "lab -cvL --ignore store@sparkles"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@phated/eslint-config-iceddev": "^0.2.1",
+    "code": "^1.5.0",
+    "eslint": "^1.3.1",
+    "eslint-plugin-mocha": "^0.5.1",
+    "eslint-plugin-react": "^3.3.1",
+    "lab": "^5.16.0"
+  },
+  "keywords": [
+    "ee",
+    "emitter",
+    "events",
+    "global",
+    "namespaced"
+  ],
+  "gitHead": "66eed55eeac9f3ba641d4643c5ad2ed598bc6a72",
+  "bugs": {
+    "url": "https://github.com/phated/sparkles/issues"
+  },
+  "homepage": "https://github.com/phated/sparkles#readme",
+  "_id": "sparkles@1.0.0",
+  "_shasum": "1acbbfb592436d10bbe8f785b7cc6f82815012c3",
+  "_from": "sparkles@>=1.0.0 <2.0.0",
+  "_npmVersion": "2.8.3",
+  "_nodeVersion": "0.10.36",
+  "_npmUser": {
+    "name": "phated",
+    "email": "blaine@iceddev.com"
+  },
+  "maintainers": [
+    {
+      "name": "phated",
+      "email": "blaine@iceddev.com"
+    }
+  ],
+  "dist": {
+    "shasum": "1acbbfb592436d10bbe8f785b7cc6f82815012c3",
+    "tarball": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.0.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/sparkles/-/sparkles-1.0.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

node_modules/gulp-uglify/node_modules/has-gulplog/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "has-gulplog",
+  "version": "0.1.0",
+  "description": "Check if gulplog is available before attempting to use it",
+  "author": {
+    "name": "Blaine Bublitz",
+    "email": "blaine@iceddev.com",
+    "url": "http://iceddev.com"
+  },
+  "contributors": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gulpjs/has-gulplog.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "eslint *.js"
+  },
+  "dependencies": {
+    "sparkles": "^1.0.0"
+  },
+  "devDependencies": {
+    "eslint": "^1.3.1"
+  },
+  "keywords": [
+    "gulp-util",
+    "gulplog",
+    "logging"
+  ],
+  "gitHead": "16ef7af9911ec91838b2762bf1ba38b4578e6f6f",
+  "bugs": {
+    "url": "https://github.com/gulpjs/has-gulplog/issues"
+  },
+  "homepage": "https://github.com/gulpjs/has-gulplog#readme",
+  "_id": "has-gulplog@0.1.0",
+  "_shasum": "6414c82913697da51590397dafb12f22967811ce",
+  "_from": "has-gulplog@>=0.1.0 <0.2.0",
+  "_npmVersion": "2.8.3",
+  "_nodeVersion": "0.10.36",
+  "_npmUser": {
+    "name": "phated",
+    "email": "blaine@iceddev.com"
+  },
+  "maintainers": [
+    {
+      "name": "phated",
+      "email": "blaine@iceddev.com"
+    }
+  ],
+  "dist": {
+    "shasum": "6414c82913697da51590397dafb12f22967811ce",
+    "tarball": "https://registry.npmjs.org/has-gulplog/-/has-gulplog-0.1.0.tgz"
+  },
+  "directories": {},
+  "_resolved": "https://registry.npmjs.org/has-gulplog/-/has-gulplog-0.1.0.tgz",
+  "readme": "ERROR: No README data found!"
+}

node_modules/gulp-uglify/node_modules/lodash/LICENSE

@@ -0,0 +1,47 @@
+Copyright JS Foundation and other contributors <https://js.foundation/>
+
+Based on Underscore.js, copyright Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+This software consists of voluntary contributions made by many
+individuals. For exact contribution history, see the revision history
+available at https://github.com/lodash/lodash
+
+The following license applies to all parts of this software except as
+documented below:
+
+====
+
+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.
+
+====
+
+Copyright and related rights for sample code are waived via CC0. Sample
+code is defined as all source code displayed within the prose of the
+documentation.
+
+CC0: http://creativecommons.org/publicdomain/zero/1.0/
+
+====
+
+Files located in the node_modules and vendor directories are externally
+maintained libraries used by this software which have their own
+licenses; we recommend you read them, as their terms may differ from the
+terms above.

node_modules/gulp-uglify/node_modules/lodash/README.md

@@ -0,0 +1,39 @@
+# lodash v4.17.5
+
+The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.
+
+## Installation
+
+Using npm:
+```shell
+$ npm i -g npm
+$ npm i --save lodash
+```
+
+In Node.js:
+```js
+// Load the full build.
+var _ = require('lodash');
+// Load the core build.
+var _ = require('lodash/core');
+// Load the FP build for immutable auto-curried iteratee-first data-last methods.
+var fp = require('lodash/fp');
+
+// Load method categories.
+var array = require('lodash/array');
+var object = require('lodash/fp/object');
+
+// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
+var at = require('lodash/at');
+var curryN = require('lodash/fp/curryN');
+```
+
+See the [package source](https://github.com/lodash/lodash/tree/4.17.5-npm) for more details.
+
+**Note:**<br>
+Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL.
+
+## Support
+
+Tested in Chrome 63-64, Firefox 57-58, IE 11, Edge 14, Safari 10-11, Node.js 4-9, & PhantomJS 2.1.1.<br>
+Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available.

node_modules/gulp-uglify/node_modules/lodash/_DataView.js

@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView');
+
+module.exports = DataView;

node_modules/gulp-uglify/node_modules/lodash/_Hash.js

@@ -0,0 +1,32 @@
+var hashClear = require('./_hashClear'),
+    hashDelete = require('./_hashDelete'),
+    hashGet = require('./_hashGet'),
+    hashHas = require('./_hashHas'),
+    hashSet = require('./_hashSet');
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+module.exports = Hash;

node_modules/gulp-uglify/node_modules/lodash/_LazyWrapper.js

@@ -0,0 +1,28 @@
+var baseCreate = require('./_baseCreate'),
+    baseLodash = require('./_baseLodash');
+
+/** Used as references for the maximum length and index of an array. */
+var MAX_ARRAY_LENGTH = 4294967295;
+
+/**
+ * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
+ *
+ * @private
+ * @constructor
+ * @param {*} value The value to wrap.
+ */
+function LazyWrapper(value) {
+  this.__wrapped__ = value;
+  this.__actions__ = [];
+  this.__dir__ = 1;
+  this.__filtered__ = false;
+  this.__iteratees__ = [];
+  this.__takeCount__ = MAX_ARRAY_LENGTH;
+  this.__views__ = [];
+}
+
+// Ensure `LazyWrapper` is an instance of `baseLodash`.
+LazyWrapper.prototype = baseCreate(baseLodash.prototype);
+LazyWrapper.prototype.constructor = LazyWrapper;
+
+module.exports = LazyWrapper;

node_modules/gulp-uglify/node_modules/lodash/_ListCache.js

@@ -0,0 +1,32 @@
+var listCacheClear = require('./_listCacheClear'),
+    listCacheDelete = require('./_listCacheDelete'),
+    listCacheGet = require('./_listCacheGet'),
+    listCacheHas = require('./_listCacheHas'),
+    listCacheSet = require('./_listCacheSet');
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+module.exports = ListCache;

node_modules/gulp-uglify/node_modules/lodash/_LodashWrapper.js

@@ -0,0 +1,22 @@
+var baseCreate = require('./_baseCreate'),
+    baseLodash = require('./_baseLodash');
+
+/**
+ * The base constructor for creating `lodash` wrapper objects.
+ *
+ * @private
+ * @param {*} value The value to wrap.
+ * @param {boolean} [chainAll] Enable explicit method chain sequences.
+ */
+function LodashWrapper(value, chainAll) {
+  this.__wrapped__ = value;
+  this.__actions__ = [];
+  this.__chain__ = !!chainAll;
+  this.__index__ = 0;
+  this.__values__ = undefined;
+}
+
+LodashWrapper.prototype = baseCreate(baseLodash.prototype);
+LodashWrapper.prototype.constructor = LodashWrapper;
+
+module.exports = LodashWrapper;

node_modules/gulp-uglify/node_modules/lodash/_Map.js

@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Map = getNative(root, 'Map');
+
+module.exports = Map;

node_modules/gulp-uglify/node_modules/lodash/_MapCache.js

@@ -0,0 +1,32 @@
+var mapCacheClear = require('./_mapCacheClear'),
+    mapCacheDelete = require('./_mapCacheDelete'),
+    mapCacheGet = require('./_mapCacheGet'),
+    mapCacheHas = require('./_mapCacheHas'),
+    mapCacheSet = require('./_mapCacheSet');
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+module.exports = MapCache;

node_modules/gulp-uglify/node_modules/lodash/_Promise.js

@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Promise = getNative(root, 'Promise');
+
+module.exports = Promise;

node_modules/gulp-uglify/node_modules/lodash/_Set.js

@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var Set = getNative(root, 'Set');
+
+module.exports = Set;

node_modules/gulp-uglify/node_modules/lodash/_SetCache.js

@@ -0,0 +1,27 @@
+var MapCache = require('./_MapCache'),
+    setCacheAdd = require('./_setCacheAdd'),
+    setCacheHas = require('./_setCacheHas');
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+  var index = -1,
+      length = values == null ? 0 : values.length;
+
+  this.__data__ = new MapCache;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+module.exports = SetCache;

node_modules/gulp-uglify/node_modules/lodash/_Stack.js

@@ -0,0 +1,27 @@
+var ListCache = require('./_ListCache'),
+    stackClear = require('./_stackClear'),
+    stackDelete = require('./_stackDelete'),
+    stackGet = require('./_stackGet'),
+    stackHas = require('./_stackHas'),
+    stackSet = require('./_stackSet');
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+module.exports = Stack;

node_modules/gulp-uglify/node_modules/lodash/_Symbol.js

@@ -0,0 +1,6 @@
+var root = require('./_root');
+
+/** Built-in value references. */
+var Symbol = root.Symbol;
+
+module.exports = Symbol;

node_modules/gulp-uglify/node_modules/lodash/_Uint8Array.js

@@ -0,0 +1,6 @@
+var root = require('./_root');
+
+/** Built-in value references. */
+var Uint8Array = root.Uint8Array;
+
+module.exports = Uint8Array;

node_modules/gulp-uglify/node_modules/lodash/_WeakMap.js

@@ -0,0 +1,7 @@
+var getNative = require('./_getNative'),
+    root = require('./_root');
+
+/* Built-in method references that are verified to be native. */
+var WeakMap = getNative(root, 'WeakMap');
+
+module.exports = WeakMap;

node_modules/gulp-uglify/node_modules/lodash/_apply.js

@@ -0,0 +1,21 @@
+/**
+ * A faster alternative to `Function#apply`, this function invokes `func`
+ * with the `this` binding of `thisArg` and the arguments of `args`.
+ *
+ * @private
+ * @param {Function} func The function to invoke.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} args The arguments to invoke `func` with.
+ * @returns {*} Returns the result of `func`.
+ */
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0: return func.call(thisArg);
+    case 1: return func.call(thisArg, args[0]);
+    case 2: return func.call(thisArg, args[0], args[1]);
+    case 3: return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+
+module.exports = apply;

node_modules/gulp-uglify/node_modules/lodash/_arrayAggregator.js

@@ -0,0 +1,22 @@
+/**
+ * A specialized version of `baseAggregator` for arrays.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+function arrayAggregator(array, setter, iteratee, accumulator) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    var value = array[index];
+    setter(accumulator, value, iteratee(value), array);
+  }
+  return accumulator;
+}
+
+module.exports = arrayAggregator;

node_modules/gulp-uglify/node_modules/lodash/_arrayEach.js

@@ -0,0 +1,22 @@
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEach(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+module.exports = arrayEach;

node_modules/gulp-uglify/node_modules/lodash/_arrayEachRight.js

@@ -0,0 +1,21 @@
+/**
+ * A specialized version of `_.forEachRight` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEachRight(array, iteratee) {
+  var length = array == null ? 0 : array.length;
+
+  while (length--) {
+    if (iteratee(array[length], length, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+module.exports = arrayEachRight;

node_modules/gulp-uglify/node_modules/lodash/_arrayEvery.js

@@ -0,0 +1,23 @@
+/**
+ * A specialized version of `_.every` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ *  else `false`.
+ */
+function arrayEvery(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (!predicate(array[index], index, array)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = arrayEvery;

node_modules/gulp-uglify/node_modules/lodash/_arrayFilter.js

@@ -0,0 +1,25 @@
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function arrayFilter(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = arrayFilter;

node_modules/gulp-uglify/node_modules/lodash/_arrayIncludes.js

@@ -0,0 +1,17 @@
+var baseIndexOf = require('./_baseIndexOf');
+
+/**
+ * A specialized version of `_.includes` for arrays without support for
+ * specifying an index to search from.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+function arrayIncludes(array, value) {
+  var length = array == null ? 0 : array.length;
+  return !!length && baseIndexOf(array, value, 0) > -1;
+}
+
+module.exports = arrayIncludes;

node_modules/gulp-uglify/node_modules/lodash/_arrayIncludesWith.js

@@ -0,0 +1,22 @@
+/**
+ * This function is like `arrayIncludes` except that it accepts a comparator.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @param {Function} comparator The comparator invoked per element.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+function arrayIncludesWith(array, value, comparator) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (comparator(value, array[index])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = arrayIncludesWith;

node_modules/gulp-uglify/node_modules/lodash/_arrayLikeKeys.js

@@ -0,0 +1,49 @@
+var baseTimes = require('./_baseTimes'),
+    isArguments = require('./isArguments'),
+    isArray = require('./isArray'),
+    isBuffer = require('./isBuffer'),
+    isIndex = require('./_isIndex'),
+    isTypedArray = require('./isTypedArray');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value),
+      isArg = !isArr && isArguments(value),
+      isBuff = !isArr && !isArg && isBuffer(value),
+      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+      skipIndexes = isArr || isArg || isBuff || isType,
+      result = skipIndexes ? baseTimes(value.length, String) : [],
+      length = result.length;
+
+  for (var key in value) {
+    if ((inherited || hasOwnProperty.call(value, key)) &&
+        !(skipIndexes && (
+           // Safari 9 has enumerable `arguments.length` in strict mode.
+           key == 'length' ||
+           // Node.js 0.10 has enumerable non-index properties on buffers.
+           (isBuff && (key == 'offset' || key == 'parent')) ||
+           // PhantomJS 2 has enumerable non-index properties on typed arrays.
+           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+           // Skip index properties.
+           isIndex(key, length)
+        ))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+module.exports = arrayLikeKeys;

node_modules/gulp-uglify/node_modules/lodash/_arrayMap.js

@@ -0,0 +1,21 @@
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+
+module.exports = arrayMap;

node_modules/gulp-uglify/node_modules/lodash/_arrayPush.js

@@ -0,0 +1,20 @@
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+  var index = -1,
+      length = values.length,
+      offset = array.length;
+
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+
+module.exports = arrayPush;

node_modules/gulp-uglify/node_modules/lodash/_arrayReduce.js

@@ -0,0 +1,26 @@
+/**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ *  the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  if (initAccum && length) {
+    accumulator = array[++index];
+  }
+  while (++index < length) {
+    accumulator = iteratee(accumulator, array[index], index, array);
+  }
+  return accumulator;
+}
+
+module.exports = arrayReduce;

node_modules/gulp-uglify/node_modules/lodash/_arrayReduceRight.js

@@ -0,0 +1,24 @@
+/**
+ * A specialized version of `_.reduceRight` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the last element of `array` as
+ *  the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduceRight(array, iteratee, accumulator, initAccum) {
+  var length = array == null ? 0 : array.length;
+  if (initAccum && length) {
+    accumulator = array[--length];
+  }
+  while (length--) {
+    accumulator = iteratee(accumulator, array[length], length, array);
+  }
+  return accumulator;
+}
+
+module.exports = arrayReduceRight;

node_modules/gulp-uglify/node_modules/lodash/_arraySample.js

@@ -0,0 +1,15 @@
+var baseRandom = require('./_baseRandom');
+
+/**
+ * A specialized version of `_.sample` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to sample.
+ * @returns {*} Returns the random element.
+ */
+function arraySample(array) {
+  var length = array.length;
+  return length ? array[baseRandom(0, length - 1)] : undefined;
+}
+
+module.exports = arraySample;

node_modules/gulp-uglify/node_modules/lodash/_arraySampleSize.js

@@ -0,0 +1,17 @@
+var baseClamp = require('./_baseClamp'),
+    copyArray = require('./_copyArray'),
+    shuffleSelf = require('./_shuffleSelf');
+
+/**
+ * A specialized version of `_.sampleSize` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to sample.
+ * @param {number} n The number of elements to sample.
+ * @returns {Array} Returns the random elements.
+ */
+function arraySampleSize(array, n) {
+  return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
+}
+
+module.exports = arraySampleSize;

node_modules/gulp-uglify/node_modules/lodash/_arrayShuffle.js

@@ -0,0 +1,15 @@
+var copyArray = require('./_copyArray'),
+    shuffleSelf = require('./_shuffleSelf');
+
+/**
+ * A specialized version of `_.shuffle` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to shuffle.
+ * @returns {Array} Returns the new shuffled array.
+ */
+function arrayShuffle(array) {
+  return shuffleSelf(copyArray(array));
+}
+
+module.exports = arrayShuffle;

node_modules/gulp-uglify/node_modules/lodash/_arraySome.js

@@ -0,0 +1,23 @@
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function arraySome(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+module.exports = arraySome;

node_modules/gulp-uglify/node_modules/lodash/_asciiSize.js

@@ -0,0 +1,12 @@
+var baseProperty = require('./_baseProperty');
+
+/**
+ * Gets the size of an ASCII `string`.
+ *
+ * @private
+ * @param {string} string The string inspect.
+ * @returns {number} Returns the string size.
+ */
+var asciiSize = baseProperty('length');
+
+module.exports = asciiSize;

node_modules/gulp-uglify/node_modules/lodash/_asciiToArray.js

@@ -0,0 +1,12 @@
+/**
+ * Converts an ASCII `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+function asciiToArray(string) {
+  return string.split('');
+}
+
+module.exports = asciiToArray;

node_modules/gulp-uglify/node_modules/lodash/_asciiWords.js

@@ -0,0 +1,15 @@
+/** Used to match words composed of alphanumeric characters. */
+var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+
+/**
+ * Splits an ASCII `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+function asciiWords(string) {
+  return string.match(reAsciiWord) || [];
+}
+
+module.exports = asciiWords;

node_modules/gulp-uglify/node_modules/lodash/_assignMergeValue.js

@@ -0,0 +1,20 @@
+var baseAssignValue = require('./_baseAssignValue'),
+    eq = require('./eq');
+
+/**
+ * This function is like `assignValue` except that it doesn't assign
+ * `undefined` values.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignMergeValue(object, key, value) {
+  if ((value !== undefined && !eq(object[key], value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+module.exports = assignMergeValue;

node_modules/gulp-uglify/node_modules/lodash/_assignValue.js

@@ -0,0 +1,28 @@
+var baseAssignValue = require('./_baseAssignValue'),
+    eq = require('./eq');
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+module.exports = assignValue;

node_modules/gulp-uglify/node_modules/lodash/_assocIndexOf.js

@@ -0,0 +1,21 @@
+var eq = require('./eq');
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+module.exports = assocIndexOf;

node_modules/gulp-uglify/node_modules/lodash/_baseAggregator.js

@@ -0,0 +1,21 @@
+var baseEach = require('./_baseEach');
+
+/**
+ * Aggregates elements of `collection` on `accumulator` with keys transformed
+ * by `iteratee` and values set by `setter`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+function baseAggregator(collection, setter, iteratee, accumulator) {
+  baseEach(collection, function(value, key, collection) {
+    setter(accumulator, value, iteratee(value), collection);
+  });
+  return accumulator;
+}
+
+module.exports = baseAggregator;

node_modules/gulp-uglify/node_modules/lodash/_baseAssign.js

@@ -0,0 +1,17 @@
+var copyObject = require('./_copyObject'),
+    keys = require('./keys');
+
+/**
+ * The base implementation of `_.assign` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssign(object, source) {
+  return object && copyObject(source, keys(source), object);
+}
+
+module.exports = baseAssign;

node_modules/gulp-uglify/node_modules/lodash/_baseAssignIn.js

@@ -0,0 +1,17 @@
+var copyObject = require('./_copyObject'),
+    keysIn = require('./keysIn');
+
+/**
+ * The base implementation of `_.assignIn` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssignIn(object, source) {
+  return object && copyObject(source, keysIn(source), object);
+}
+
+module.exports = baseAssignIn;

node_modules/gulp-uglify/node_modules/lodash/_baseAssignValue.js

@@ -0,0 +1,25 @@
+var defineProperty = require('./_defineProperty');
+
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function baseAssignValue(object, key, value) {
+  if (key == '__proto__' && defineProperty) {
+    defineProperty(object, key, {
+      'configurable': true,
+      'enumerable': true,
+      'value': value,
+      'writable': true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+
+module.exports = baseAssignValue;

node_modules/gulp-uglify/node_modules/lodash/_baseAt.js

@@ -0,0 +1,23 @@
+var get = require('./get');
+
+/**
+ * The base implementation of `_.at` without support for individual paths.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {string[]} paths The property paths to pick.
+ * @returns {Array} Returns the picked elements.
+ */
+function baseAt(object, paths) {
+  var index = -1,
+      length = paths.length,
+      result = Array(length),
+      skip = object == null;
+
+  while (++index < length) {
+    result[index] = skip ? undefined : get(object, paths[index]);
+  }
+  return result;
+}
+
+module.exports = baseAt;

node_modules/gulp-uglify/node_modules/lodash/_baseClamp.js

@@ -0,0 +1,22 @@
+/**
+ * The base implementation of `_.clamp` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {number} number The number to clamp.
+ * @param {number} [lower] The lower bound.
+ * @param {number} upper The upper bound.
+ * @returns {number} Returns the clamped number.
+ */
+function baseClamp(number, lower, upper) {
+  if (number === number) {
+    if (upper !== undefined) {
+      number = number <= upper ? number : upper;
+    }
+    if (lower !== undefined) {
+      number = number >= lower ? number : lower;
+    }
+  }
+  return number;
+}
+
+module.exports = baseClamp;

node_modules/gulp-uglify/node_modules/lodash/_baseClone.js

@@ -0,0 +1,171 @@
+var Stack = require('./_Stack'),
+    arrayEach = require('./_arrayEach'),
+    assignValue = require('./_assignValue'),
+    baseAssign = require('./_baseAssign'),
+    baseAssignIn = require('./_baseAssignIn'),
+    cloneBuffer = require('./_cloneBuffer'),
+    copyArray = require('./_copyArray'),
+    copySymbols = require('./_copySymbols'),
+    copySymbolsIn = require('./_copySymbolsIn'),
+    getAllKeys = require('./_getAllKeys'),
+    getAllKeysIn = require('./_getAllKeysIn'),
+    getTag = require('./_getTag'),
+    initCloneArray = require('./_initCloneArray'),
+    initCloneByTag = require('./_initCloneByTag'),
+    initCloneObject = require('./_initCloneObject'),
+    isArray = require('./isArray'),
+    isBuffer = require('./isBuffer'),
+    isMap = require('./isMap'),
+    isObject = require('./isObject'),
+    isSet = require('./isSet'),
+    keys = require('./keys');
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_FLAT_FLAG = 2,
+    CLONE_SYMBOLS_FLAG = 4;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] =
+cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+cloneableTags[boolTag] = cloneableTags[dateTag] =
+cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+cloneableTags[int32Tag] = cloneableTags[mapTag] =
+cloneableTags[numberTag] = cloneableTags[objectTag] =
+cloneableTags[regexpTag] = cloneableTags[setTag] =
+cloneableTags[stringTag] = cloneableTags[symbolTag] =
+cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] =
+cloneableTags[weakMapTag] = false;
+
+/**
+ * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+ * traversed objects.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Deep clone
+ *  2 - Flatten inherited properties
+ *  4 - Clone symbols
+ * @param {Function} [customizer] The function to customize cloning.
+ * @param {string} [key] The key of `value`.
+ * @param {Object} [object] The parent object of `value`.
+ * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+function baseClone(value, bitmask, customizer, key, object, stack) {
+  var result,
+      isDeep = bitmask & CLONE_DEEP_FLAG,
+      isFlat = bitmask & CLONE_FLAT_FLAG,
+      isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
+  if (customizer) {
+    result = object ? customizer(value, key, object, stack) : customizer(value);
+  }
+  if (result !== undefined) {
+    return result;
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    if (!isDeep) {
+      return copyArray(value, result);
+    }
+  } else {
+    var tag = getTag(value),
+        isFunc = tag == funcTag || tag == genTag;
+
+    if (isBuffer(value)) {
+      return cloneBuffer(value, isDeep);
+    }
+    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+      result = (isFlat || isFunc) ? {} : initCloneObject(value);
+      if (!isDeep) {
+        return isFlat
+          ? copySymbolsIn(value, baseAssignIn(result, value))
+          : copySymbols(value, baseAssign(result, value));
+      }
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag(value, tag, isDeep);
+    }
+  }
+  // Check for circular references and return its corresponding clone.
+  stack || (stack = new Stack);
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+    });
+
+    return result;
+  }
+
+  if (isMap(value)) {
+    value.forEach(function(subValue, key) {
+      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+    });
+
+    return result;
+  }
+
+  var keysFunc = isFull
+    ? (isFlat ? getAllKeysIn : getAllKeys)
+    : (isFlat ? keysIn : keys);
+
+  var props = isArr ? undefined : keysFunc(value);
+  arrayEach(props || value, function(subValue, key) {
+    if (props) {
+      key = subValue;
+      subValue = value[key];
+    }
+    // Recursively populate clone (susceptible to call stack limits).
+    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+  });
+  return result;
+}
+
+module.exports = baseClone;

node_modules/gulp-uglify/node_modules/lodash/_baseConforms.js

@@ -0,0 +1,18 @@
+var baseConformsTo = require('./_baseConformsTo'),
+    keys = require('./keys');
+
+/**
+ * The base implementation of `_.conforms` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property predicates to conform to.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseConforms(source) {
+  var props = keys(source);
+  return function(object) {
+    return baseConformsTo(object, source, props);
+  };
+}
+
+module.exports = baseConforms;

node_modules/gulp-uglify/node_modules/lodash/_baseConformsTo.js

@@ -0,0 +1,27 @@
+/**
+ * The base implementation of `_.conformsTo` which accepts `props` to check.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property predicates to conform to.
+ * @returns {boolean} Returns `true` if `object` conforms, else `false`.
+ */
+function baseConformsTo(object, source, props) {
+  var length = props.length;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (length--) {
+    var key = props[length],
+        predicate = source[key],
+        value = object[key];
+
+    if ((value === undefined && !(key in object)) || !predicate(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+module.exports = baseConformsTo;

node_modules/gulp-uglify/node_modules/lodash/_baseCreate.js

@@ -0,0 +1,30 @@
+var isObject = require('./isObject');
+
+/** Built-in value references. */
+var objectCreate = Object.create;
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+var baseCreate = (function() {
+  function object() {}
+  return function(proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object;
+    object.prototype = undefined;
+    return result;
+  };
+}());
+
+module.exports = baseCreate;

node_modules/gulp-uglify/node_modules/lodash/_baseDelay.js

@@ -0,0 +1,21 @@
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * The base implementation of `_.delay` and `_.defer` which accepts `args`
+ * to provide to `func`.
+ *
+ * @private
+ * @param {Function} func The function to delay.
+ * @param {number} wait The number of milliseconds to delay invocation.
+ * @param {Array} args The arguments to provide to `func`.
+ * @returns {number|Object} Returns the timer id or timeout object.
+ */
+function baseDelay(func, wait, args) {
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  return setTimeout(function() { func.apply(undefined, args); }, wait);
+}
+
+module.exports = baseDelay;

node_modules/gulp-uglify/node_modules/lodash/_baseDifference.js

@@ -0,0 +1,67 @@
+var SetCache = require('./_SetCache'),
+    arrayIncludes = require('./_arrayIncludes'),
+    arrayIncludesWith = require('./_arrayIncludesWith'),
+    arrayMap = require('./_arrayMap'),
+    baseUnary = require('./_baseUnary'),
+    cacheHas = require('./_cacheHas');
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * The base implementation of methods like `_.difference` without support
+ * for excluding multiple arrays or iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Array} values The values to exclude.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ */
+function baseDifference(array, values, iteratee, comparator) {
+  var index = -1,
+      includes = arrayIncludes,
+      isCommon = true,
+      length = array.length,
+      result = [],
+      valuesLength = values.length;
+
+  if (!length) {
+    return result;
+  }
+  if (iteratee) {
+    values = arrayMap(values, baseUnary(iteratee));
+  }
+  if (comparator) {
+    includes = arrayIncludesWith;
+    isCommon = false;
+  }
+  else if (values.length >= LARGE_ARRAY_SIZE) {
+    includes = cacheHas;
+    isCommon = false;
+    values = new SetCache(values);
+  }
+  outer:
+  while (++index < length) {
+    var value = array[index],
+        computed = iteratee == null ? value : iteratee(value);
+
+    value = (comparator || value !== 0) ? value : 0;
+    if (isCommon && computed === computed) {
+      var valuesIndex = valuesLength;
+      while (valuesIndex--) {
+        if (values[valuesIndex] === computed) {
+          continue outer;
+        }
+      }
+      result.push(value);
+    }
+    else if (!includes(values, computed, comparator)) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+module.exports = baseDifference;

node_modules/gulp-uglify/node_modules/lodash/_baseEach.js

@@ -0,0 +1,14 @@
+var baseForOwn = require('./_baseForOwn'),
+    createBaseEach = require('./_createBaseEach');
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = createBaseEach(baseForOwn);
+
+module.exports = baseEach;

node_modules/gulp-uglify/node_modules/lodash/_baseEachRight.js

@@ -0,0 +1,14 @@
+var baseForOwnRight = require('./_baseForOwnRight'),
+    createBaseEach = require('./_createBaseEach');
+
+/**
+ * The base implementation of `_.forEachRight` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEachRight = createBaseEach(baseForOwnRight, true);
+
+module.exports = baseEachRight;

node_modules/gulp-uglify/node_modules/lodash/_baseEvery.js

@@ -0,0 +1,21 @@
+var baseEach = require('./_baseEach');
+
+/**
+ * The base implementation of `_.every` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ *  else `false`
+ */
+function baseEvery(collection, predicate) {
+  var result = true;
+  baseEach(collection, function(value, index, collection) {
+    result = !!predicate(value, index, collection);
+    return result;
+  });
+  return result;
+}
+
+module.exports = baseEvery;

node_modules/gulp-uglify/node_modules/lodash/_baseExtremum.js

@@ -0,0 +1,32 @@
+var isSymbol = require('./isSymbol');
+
+/**
+ * The base implementation of methods like `_.max` and `_.min` which accepts a
+ * `comparator` to determine the extremum value.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The iteratee invoked per iteration.
+ * @param {Function} comparator The comparator used to compare values.
+ * @returns {*} Returns the extremum value.
+ */
+function baseExtremum(array, iteratee, comparator) {
+  var index = -1,
+      length = array.length;
+
+  while (++index < length) {
+    var value = array[index],
+        current = iteratee(value);
+
+    if (current != null && (computed === undefined
+          ? (current === current && !isSymbol(current))
+          : comparator(current, computed)
+        )) {
+      var computed = current,
+          result = value;
+    }
+  }
+  return result;
+}
+
+module.exports = baseExtremum;

node_modules/gulp-uglify/node_modules/lodash/_baseFill.js

@@ -0,0 +1,32 @@
+var toInteger = require('./toInteger'),
+    toLength = require('./toLength');
+
+/**
+ * The base implementation of `_.fill` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to fill.
+ * @param {*} value The value to fill `array` with.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns `array`.
+ */
+function baseFill(array, value, start, end) {
+  var length = array.length;
+
+  start = toInteger(start);
+  if (start < 0) {
+    start = -start > length ? 0 : (length + start);
+  }
+  end = (end === undefined || end > length) ? length : toInteger(end);
+  if (end < 0) {
+    end += length;
+  }
+  end = start > end ? 0 : toLength(end);
+  while (start < end) {
+    array[start++] = value;
+  }
+  return array;
+}
+
+module.exports = baseFill;

node_modules/gulp-uglify/node_modules/lodash/_baseFilter.js

@@ -0,0 +1,21 @@
+var baseEach = require('./_baseEach');
+
+/**
+ * The base implementation of `_.filter` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function baseFilter(collection, predicate) {
+  var result = [];
+  baseEach(collection, function(value, index, collection) {
+    if (predicate(value, index, collection)) {
+      result.push(value);
+    }
+  });
+  return result;
+}
+
+module.exports = baseFilter;

node_modules/gulp-uglify/node_modules/lodash/_baseFindIndex.js

@@ -0,0 +1,24 @@
+/**
+ * The base implementation of `_.findIndex` and `_.findLastIndex` without
+ * support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {number} fromIndex The index to search from.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+  var length = array.length,
+      index = fromIndex + (fromRight ? 1 : -1);
+
+  while ((fromRight ? index-- : ++index < length)) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+module.exports = baseFindIndex;

node_modules/gulp-uglify/node_modules/lodash/_baseFindKey.js

@@ -0,0 +1,23 @@
+/**
+ * The base implementation of methods like `_.findKey` and `_.findLastKey`,
+ * without support for iteratee shorthands, which iterates over `collection`
+ * using `eachFunc`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {Function} eachFunc The function to iterate over `collection`.
+ * @returns {*} Returns the found element or its key, else `undefined`.
+ */
+function baseFindKey(collection, predicate, eachFunc) {
+  var result;
+  eachFunc(collection, function(value, key, collection) {
+    if (predicate(value, key, collection)) {
+      result = key;
+      return false;
+    }
+  });
+  return result;
+}
+
+module.exports = baseFindKey;

node_modules/gulp-uglify/node_modules/lodash/_baseFlatten.js

@@ -0,0 +1,38 @@
+var arrayPush = require('./_arrayPush'),
+    isFlattenable = require('./_isFlattenable');
+
+/**
+ * The base implementation of `_.flatten` with support for restricting flattening.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {number} depth The maximum recursion depth.
+ * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+ * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+ * @param {Array} [result=[]] The initial result value.
+ * @returns {Array} Returns the new flattened array.
+ */
+function baseFlatten(array, depth, predicate, isStrict, result) {
+  var index = -1,
+      length = array.length;
+
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+
+  while (++index < length) {
+    var value = array[index];
+    if (depth > 0 && predicate(value)) {
+      if (depth > 1) {
+        // Recursively flatten arrays (susceptible to call stack limits).
+        baseFlatten(value, depth - 1, predicate, isStrict, result);
+      } else {
+        arrayPush(result, value);
+      }
+    } else if (!isStrict) {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+
+module.exports = baseFlatten;

node_modules/gulp-uglify/node_modules/lodash/_baseFor.js

@@ -0,0 +1,16 @@
+var createBaseFor = require('./_createBaseFor');
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+module.exports = baseFor;

node_modules/gulp-uglify/node_modules/lodash/_baseForOwn.js

@@ -0,0 +1,16 @@
+var baseFor = require('./_baseFor'),
+    keys = require('./keys');
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+
+module.exports = baseForOwn;

node_modules/gulp-uglify/node_modules/lodash/_baseForOwnRight.js

@@ -0,0 +1,16 @@
+var baseForRight = require('./_baseForRight'),
+    keys = require('./keys');
+
+/**
+ * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwnRight(object, iteratee) {
+  return object && baseForRight(object, iteratee, keys);
+}
+
+module.exports = baseForOwnRight;

node_modules/gulp-uglify/node_modules/lodash/_baseForRight.js

@@ -0,0 +1,15 @@
+var createBaseFor = require('./_createBaseFor');
+
+/**
+ * This function is like `baseFor` except that it iterates over properties
+ * in the opposite order.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseForRight = createBaseFor(true);
+
+module.exports = baseForRight;

node_modules/gulp-uglify/node_modules/lodash/_baseFunctions.js

@@ -0,0 +1,19 @@
+var arrayFilter = require('./_arrayFilter'),
+    isFunction = require('./isFunction');
+
+/**
+ * The base implementation of `_.functions` which creates an array of
+ * `object` function property names filtered from `props`.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Array} props The property names to filter.
+ * @returns {Array} Returns the function names.
+ */
+function baseFunctions(object, props) {
+  return arrayFilter(props, function(key) {
+    return isFunction(object[key]);
+  });
+}
+
+module.exports = baseFunctions;

node_modules/gulp-uglify/node_modules/lodash/_baseGet.js

@@ -0,0 +1,24 @@
+var castPath = require('./_castPath'),
+    toKey = require('./_toKey');
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+  path = castPath(path, object);
+
+  var index = 0,
+      length = path.length;
+
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return (index && index == length) ? object : undefined;
+}
+
+module.exports = baseGet;

node_modules/gulp-uglify/node_modules/lodash/_baseGetAllKeys.js

@@ -0,0 +1,20 @@
+var arrayPush = require('./_arrayPush'),
+    isArray = require('./isArray');
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+
+module.exports = baseGetAllKeys;

node_modules/gulp-uglify/node_modules/lodash/_baseGetTag.js

@@ -0,0 +1,28 @@
+var Symbol = require('./_Symbol'),
+    getRawTag = require('./_getRawTag'),
+    objectToString = require('./_objectToString');
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+    undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return (symToStringTag && symToStringTag in Object(value))
+    ? getRawTag(value)
+    : objectToString(value);
+}
+
+module.exports = baseGetTag;

node_modules/gulp-uglify/node_modules/lodash/_baseGt.js

@@ -0,0 +1,14 @@
+/**
+ * The base implementation of `_.gt` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is greater than `other`,
+ *  else `false`.
+ */
+function baseGt(value, other) {
+  return value > other;
+}
+
+module.exports = baseGt;