A new start

node_modules/gulp-minify/node_modules/clone-stats/LICENSE.md

@@ -0,0 +1,21 @@
+## The MIT License (MIT) ##
+
+Copyright (c) 2014 Hugh Kennedy
+
+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-minify/node_modules/clone-stats/README.md

@@ -0,0 +1,17 @@
+# clone-stats [![Flattr this!](https://api.flattr.com/button/flattr-badge-large.png)](https://flattr.com/submit/auto?user_id=hughskennedy&url=http://github.com/hughsk/clone-stats&title=clone-stats&description=hughsk/clone-stats%20on%20GitHub&language=en_GB&tags=flattr,github,javascript&category=software)[![experimental](http://hughsk.github.io/stability-badges/dist/experimental.svg)](http://github.com/hughsk/stability-badges) #
+
+Safely clone node's
+[`fs.Stats`](http://nodejs.org/api/fs.html#fs_class_fs_stats) instances without
+losing their class methods, i.e. `stat.isDirectory()` and co.
+
+## Usage ##
+
+[![clone-stats](https://nodei.co/npm/clone-stats.png?mini=true)](https://nodei.co/npm/clone-stats)
+
+### `copy = require('clone-stats')(stat)` ###
+
+Returns a clone of the original `fs.Stats` instance (`stat`).
+
+## License ##
+
+MIT. See [LICENSE.md](http://github.com/hughsk/clone-stats/blob/master/LICENSE.md) for details.

node_modules/gulp-minify/node_modules/clone-stats/index.js

@@ -0,0 +1,13 @@
+var Stat = require('fs').Stats
+
+module.exports = cloneStats
+
+function cloneStats(stats) {
+  var replacement = new Stat
+
+  Object.keys(stats).forEach(function(key) {
+    replacement[key] = stats[key]
+  })
+
+  return replacement
+}

node_modules/gulp-minify/node_modules/clone-stats/package.json

@@ -0,0 +1,60 @@
+{
+  "_from": "clone-stats@^1.0.0",
+  "_id": "clone-stats@1.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-s3gt/4u1R04Yuba/D9/ngvh3doA=",
+  "_location": "/gulp-minify/clone-stats",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "clone-stats@^1.0.0",
+    "name": "clone-stats",
+    "escapedName": "clone-stats",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/gulp-minify/vinyl"
+  ],
+  "_resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-1.0.0.tgz",
+  "_shasum": "b3782dff8bb5474e18b9b6bf0fdfe782f8777680",
+  "_spec": "clone-stats@^1.0.0",
+  "_where": "/var/www/html/autocompletion/node_modules/gulp-minify/node_modules/vinyl",
+  "author": {
+    "name": "Hugh Kennedy",
+    "email": "hughskennedy@gmail.com",
+    "url": "http://hughsk.io/"
+  },
+  "browser": "index.js",
+  "bugs": {
+    "url": "https://github.com/hughsk/clone-stats/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {},
+  "deprecated": false,
+  "description": "Safely clone node's fs.Stats instances without losing their class methods",
+  "devDependencies": {
+    "tape": "~2.3.2"
+  },
+  "homepage": "https://github.com/hughsk/clone-stats",
+  "keywords": [
+    "stats",
+    "fs",
+    "clone",
+    "copy",
+    "prototype"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "clone-stats",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/hughsk/clone-stats.git"
+  },
+  "scripts": {
+    "test": "node test"
+  },
+  "version": "1.0.0"
+}

node_modules/gulp-minify/node_modules/clone-stats/test.js

@@ -0,0 +1,36 @@
+var test = require('tape')
+var clone = require('./')
+var fs = require('fs')
+
+test('file', function(t) {
+  compare(t, fs.statSync(__filename))
+  t.end()
+})
+
+test('directory', function(t) {
+  compare(t, fs.statSync(__dirname))
+  t.end()
+})
+
+function compare(t, stat) {
+  var copy = clone(stat)
+
+  t.deepEqual(stat, copy, 'clone has equal properties')
+  t.ok(stat instanceof fs.Stats, 'original is an fs.Stat')
+  t.ok(copy instanceof fs.Stats, 'copy is an fs.Stat')
+
+  ;['isDirectory'
+  , 'isFile'
+  , 'isBlockDevice'
+  , 'isCharacterDevice'
+  , 'isSymbolicLink'
+  , 'isFIFO'
+  , 'isSocket'
+  ].forEach(function(method) {
+    t.equal(
+        stat[method].call(stat)
+      , copy[method].call(copy)
+      , 'equal value for stat.' + method + '()'
+    )
+  })
+}

node_modules/gulp-minify/node_modules/clone/.npmignore

@@ -0,0 +1,4 @@
+/node_modules/
+/test.js
+/.travis.yml
+*.html

node_modules/gulp-minify/node_modules/clone/LICENSE

@@ -0,0 +1,18 @@
+Copyright © 2011-2015 Paul Vorbach <paul@vorba.ch>
+
+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, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/gulp-minify/node_modules/clone/README.md

@@ -0,0 +1,194 @@
+# clone
+
+[![build status](https://secure.travis-ci.org/pvorb/clone.svg)](http://travis-ci.org/pvorb/clone) [![downloads](https://img.shields.io/npm/dt/clone.svg)](http://npm-stat.com/charts.html?package=clone)
+
+offers foolproof _deep cloning_ of objects, arrays, numbers, strings, maps,
+sets, promises, etc. in JavaScript.
+
+**XSS vulnerability detected**
+
+
+## Installation
+
+    npm install clone
+
+(It also works with browserify, ender or standalone. You may want to use the
+option `noParse` in browserify to reduce the resulting file size, since usually
+`Buffer`s are not needed in browsers.)
+
+
+## Example
+
+~~~ javascript
+var clone = require('clone');
+
+var a, b;
+
+a = { foo: { bar: 'baz' } };  // initial value of a
+
+b = clone(a);                 // clone a -> b
+a.foo.bar = 'foo';            // change a
+
+console.log(a);               // show a
+console.log(b);               // show b
+~~~
+
+This will print:
+
+~~~ javascript
+{ foo: { bar: 'foo' } }
+{ foo: { bar: 'baz' } }
+~~~
+
+**clone** masters cloning simple objects (even with custom prototype), arrays,
+Date objects, and RegExp objects. Everything is cloned recursively, so that you
+can clone dates in arrays in objects, for example.
+
+
+## API
+
+`clone(val, circular, depth)`
+
+  * `val` -- the value that you want to clone, any type allowed
+  * `circular` -- boolean
+
+    Call `clone` with `circular` set to `false` if you are certain that `obj`
+    contains no circular references. This will give better performance if
+    needed. There is no error if `undefined` or `null` is passed as `obj`.
+  * `depth` -- depth to which the object is to be cloned (optional,
+    defaults to infinity)
+  * `prototype` -- sets the prototype to be used when cloning an object.
+    (optional, defaults to parent prototype).
+  * `includeNonEnumerable` -- set to `true` if the non-enumerable properties
+    should be cloned as well. Non-enumerable properties on the prototype chain
+    will be ignored. (optional, defaults to `false`)
+
+`clone.clonePrototype(obj)`
+
+  * `obj` -- the object that you want to clone
+
+Does a prototype clone as
+[described by Oran Looney](http://oranlooney.com/functional-javascript/).
+
+
+## Circular References
+
+~~~ javascript
+var a, b;
+
+a = { hello: 'world' };
+
+a.myself = a;
+b = clone(a);
+
+console.log(b);
+~~~
+
+This will print:
+
+~~~ javascript
+{ hello: "world", myself: [Circular] }
+~~~
+
+So, `b.myself` points to `b`, not `a`. Neat!
+
+
+## Test
+
+    npm test
+
+
+## Changelog
+
+### v2.1.2
+
+#### 2018-03-21
+
+  - Use `Buffer.allocUnsafe()` on Node >= 4.5.0 (contributed by @ChALkeR)
+
+### v2.1.1
+
+#### 2017-03-09
+
+  - Fix build badge in README
+  - Add support for cloning Maps and Sets on Internet Explorer
+
+### v2.1.0
+
+#### 2016-11-22
+
+  - Add support for cloning Errors
+  - Exclude non-enumerable symbol-named object properties from cloning
+  - Add option to include non-enumerable own properties of objects
+
+### v2.0.0
+
+#### 2016-09-28
+
+  - Add support for cloning ES6 Maps, Sets, Promises, and Symbols
+
+### v1.0.3
+
+#### 2017-11-08
+
+  - Close XSS vulnerability in the NPM package, which included the file
+    `test-apart-ctx.html`. This vulnerability was disclosed by Juho Nurminen of
+    2NS - Second Nature Security.
+
+### v1.0.2 (deprecated)
+
+#### 2015-03-25
+
+  - Fix call on getRegExpFlags
+  - Refactor utilities
+  - Refactor test suite
+
+### v1.0.1 (deprecated)
+
+#### 2015-03-04
+
+  - Fix nodeunit version
+  - Directly call getRegExpFlags
+
+### v1.0.0 (deprecated)
+
+#### 2015-02-10
+
+  - Improve browser support
+  - Improve browser testability
+  - Move helper methods to private namespace
+
+## Caveat
+
+Some special objects like a socket or `process.stdout`/`stderr` are known to not
+be cloneable. If you find other objects that cannot be cloned, please [open an
+issue](https://github.com/pvorb/clone/issues/new).
+
+
+## Bugs and Issues
+
+If you encounter any bugs or issues, feel free to [open an issue at
+github](https://github.com/pvorb/clone/issues) or send me an email to
+<paul@vorba.ch>. I also always like to hear from you, if you’re using my code.
+
+## License
+
+Copyright © 2011-2016 [Paul Vorbach](https://paul.vorba.ch/) and
+[contributors](https://github.com/pvorb/clone/graphs/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, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/gulp-minify/node_modules/clone/clone.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="clone node_modules" level="project" />
+  </component>
+</module>

node_modules/gulp-minify/node_modules/clone/clone.js

@@ -0,0 +1,257 @@
+var clone = (function() {
+'use strict';
+
+function _instanceof(obj, type) {
+  return type != null && obj instanceof type;
+}
+
+var nativeMap;
+try {
+  nativeMap = Map;
+} catch(_) {
+  // maybe a reference error because no `Map`. Give it a dummy value that no
+  // value will ever be an instanceof.
+  nativeMap = function() {};
+}
+
+var nativeSet;
+try {
+  nativeSet = Set;
+} catch(_) {
+  nativeSet = function() {};
+}
+
+var nativePromise;
+try {
+  nativePromise = Promise;
+} catch(_) {
+  nativePromise = function() {};
+}
+
+/**
+ * Clones (copies) an Object using deep copying.
+ *
+ * This function supports circular references by default, but if you are certain
+ * there are no circular references in your object, you can save some CPU time
+ * by calling clone(obj, false).
+ *
+ * Caution: if `circular` is false and `parent` contains circular references,
+ * your program may enter an infinite loop and crash.
+ *
+ * @param `parent` - the object to be cloned
+ * @param `circular` - set to true if the object to be cloned may contain
+ *    circular references. (optional - true by default)
+ * @param `depth` - set to a number if the object is only to be cloned to
+ *    a particular depth. (optional - defaults to Infinity)
+ * @param `prototype` - sets the prototype to be used when cloning an object.
+ *    (optional - defaults to parent prototype).
+ * @param `includeNonEnumerable` - set to true if the non-enumerable properties
+ *    should be cloned as well. Non-enumerable properties on the prototype
+ *    chain will be ignored. (optional - false by default)
+*/
+function clone(parent, circular, depth, prototype, includeNonEnumerable) {
+  if (typeof circular === 'object') {
+    depth = circular.depth;
+    prototype = circular.prototype;
+    includeNonEnumerable = circular.includeNonEnumerable;
+    circular = circular.circular;
+  }
+  // maintain two arrays for circular references, where corresponding parents
+  // and children have the same index
+  var allParents = [];
+  var allChildren = [];
+
+  var useBuffer = typeof Buffer != 'undefined';
+
+  if (typeof circular == 'undefined')
+    circular = true;
+
+  if (typeof depth == 'undefined')
+    depth = Infinity;
+
+  // recurse this function so we don't reset allParents and allChildren
+  function _clone(parent, depth) {
+    // cloning null always returns null
+    if (parent === null)
+      return null;
+
+    if (depth === 0)
+      return parent;
+
+    var child;
+    var proto;
+    if (typeof parent != 'object') {
+      return parent;
+    }
+
+    if (_instanceof(parent, nativeMap)) {
+      child = new nativeMap();
+    } else if (_instanceof(parent, nativeSet)) {
+      child = new nativeSet();
+    } else if (_instanceof(parent, nativePromise)) {
+      child = new nativePromise(function (resolve, reject) {
+        parent.then(function(value) {
+          resolve(_clone(value, depth - 1));
+        }, function(err) {
+          reject(_clone(err, depth - 1));
+        });
+      });
+    } else if (clone.__isArray(parent)) {
+      child = [];
+    } else if (clone.__isRegExp(parent)) {
+      child = new RegExp(parent.source, __getRegExpFlags(parent));
+      if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+    } else if (clone.__isDate(parent)) {
+      child = new Date(parent.getTime());
+    } else if (useBuffer && Buffer.isBuffer(parent)) {
+      if (Buffer.allocUnsafe) {
+        // Node.js >= 4.5.0
+        child = Buffer.allocUnsafe(parent.length);
+      } else {
+        // Older Node.js versions
+        child = new Buffer(parent.length);
+      }
+      parent.copy(child);
+      return child;
+    } else if (_instanceof(parent, Error)) {
+      child = Object.create(parent);
+    } else {
+      if (typeof prototype == 'undefined') {
+        proto = Object.getPrototypeOf(parent);
+        child = Object.create(proto);
+      }
+      else {
+        child = Object.create(prototype);
+        proto = prototype;
+      }
+    }
+
+    if (circular) {
+      var index = allParents.indexOf(parent);
+
+      if (index != -1) {
+        return allChildren[index];
+      }
+      allParents.push(parent);
+      allChildren.push(child);
+    }
+
+    if (_instanceof(parent, nativeMap)) {
+      parent.forEach(function(value, key) {
+        var keyChild = _clone(key, depth - 1);
+        var valueChild = _clone(value, depth - 1);
+        child.set(keyChild, valueChild);
+      });
+    }
+    if (_instanceof(parent, nativeSet)) {
+      parent.forEach(function(value) {
+        var entryChild = _clone(value, depth - 1);
+        child.add(entryChild);
+      });
+    }
+
+    for (var i in parent) {
+      var attrs;
+      if (proto) {
+        attrs = Object.getOwnPropertyDescriptor(proto, i);
+      }
+
+      if (attrs && attrs.set == null) {
+        continue;
+      }
+      child[i] = _clone(parent[i], depth - 1);
+    }
+
+    if (Object.getOwnPropertySymbols) {
+      var symbols = Object.getOwnPropertySymbols(parent);
+      for (var i = 0; i < symbols.length; i++) {
+        // Don't need to worry about cloning a symbol because it is a primitive,
+        // like a number or string.
+        var symbol = symbols[i];
+        var descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
+        if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
+          continue;
+        }
+        child[symbol] = _clone(parent[symbol], depth - 1);
+        if (!descriptor.enumerable) {
+          Object.defineProperty(child, symbol, {
+            enumerable: false
+          });
+        }
+      }
+    }
+
+    if (includeNonEnumerable) {
+      var allPropertyNames = Object.getOwnPropertyNames(parent);
+      for (var i = 0; i < allPropertyNames.length; i++) {
+        var propertyName = allPropertyNames[i];
+        var descriptor = Object.getOwnPropertyDescriptor(parent, propertyName);
+        if (descriptor && descriptor.enumerable) {
+          continue;
+        }
+        child[propertyName] = _clone(parent[propertyName], depth - 1);
+        Object.defineProperty(child, propertyName, {
+          enumerable: false
+        });
+      }
+    }
+
+    return child;
+  }
+
+  return _clone(parent, depth);
+}
+
+/**
+ * Simple flat clone using prototype, accepts only objects, usefull for property
+ * override on FLAT configuration object (no nested props).
+ *
+ * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+ * works.
+ */
+clone.clonePrototype = function clonePrototype(parent) {
+  if (parent === null)
+    return null;
+
+  var c = function () {};
+  c.prototype = parent;
+  return new c();
+};
+
+// private utility functions
+
+function __objToStr(o) {
+  return Object.prototype.toString.call(o);
+}
+clone.__objToStr = __objToStr;
+
+function __isDate(o) {
+  return typeof o === 'object' && __objToStr(o) === '[object Date]';
+}
+clone.__isDate = __isDate;
+
+function __isArray(o) {
+  return typeof o === 'object' && __objToStr(o) === '[object Array]';
+}
+clone.__isArray = __isArray;
+
+function __isRegExp(o) {
+  return typeof o === 'object' && __objToStr(o) === '[object RegExp]';
+}
+clone.__isRegExp = __isRegExp;
+
+function __getRegExpFlags(re) {
+  var flags = '';
+  if (re.global) flags += 'g';
+  if (re.ignoreCase) flags += 'i';
+  if (re.multiline) flags += 'm';
+  return flags;
+}
+clone.__getRegExpFlags = __getRegExpFlags;
+
+return clone;
+})();
+
+if (typeof module === 'object' && module.exports) {
+  module.exports = clone;
+}

node_modules/gulp-minify/node_modules/clone/package.json

@@ -0,0 +1,158 @@
+{
+  "_from": "clone@^2.1.1",
+  "_id": "clone@2.1.2",
+  "_inBundle": false,
+  "_integrity": "sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=",
+  "_location": "/gulp-minify/clone",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "clone@^2.1.1",
+    "name": "clone",
+    "escapedName": "clone",
+    "rawSpec": "^2.1.1",
+    "saveSpec": null,
+    "fetchSpec": "^2.1.1"
+  },
+  "_requiredBy": [
+    "/gulp-minify/vinyl"
+  ],
+  "_resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz",
+  "_shasum": "1b7f4b9f591f1e8f83670401600345a02887435f",
+  "_spec": "clone@^2.1.1",
+  "_where": "/var/www/html/autocompletion/node_modules/gulp-minify/node_modules/vinyl",
+  "author": {
+    "name": "Paul Vorbach",
+    "email": "paul@vorba.ch",
+    "url": "http://paul.vorba.ch/"
+  },
+  "bugs": {
+    "url": "https://github.com/pvorb/node-clone/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Blake Miner",
+      "email": "miner.blake@gmail.com",
+      "url": "http://www.blakeminer.com/"
+    },
+    {
+      "name": "Tian You",
+      "email": "axqd001@gmail.com",
+      "url": "http://blog.axqd.net/"
+    },
+    {
+      "name": "George Stagas",
+      "email": "gstagas@gmail.com",
+      "url": "http://stagas.com/"
+    },
+    {
+      "name": "Tobiasz Cudnik",
+      "email": "tobiasz.cudnik@gmail.com",
+      "url": "https://github.com/TobiaszCudnik"
+    },
+    {
+      "name": "Pavel Lang",
+      "email": "langpavel@phpskelet.org",
+      "url": "https://github.com/langpavel"
+    },
+    {
+      "name": "Dan MacTough",
+      "url": "http://yabfog.com/"
+    },
+    {
+      "name": "w1nk",
+      "url": "https://github.com/w1nk"
+    },
+    {
+      "name": "Hugh Kennedy",
+      "url": "http://twitter.com/hughskennedy"
+    },
+    {
+      "name": "Dustin Diaz",
+      "url": "http://dustindiaz.com"
+    },
+    {
+      "name": "Ilya Shaisultanov",
+      "url": "https://github.com/diversario"
+    },
+    {
+      "name": "Nathan MacInnes",
+      "email": "nathan@macinn.es",
+      "url": "http://macinn.es/"
+    },
+    {
+      "name": "Benjamin E. Coe",
+      "email": "ben@npmjs.com",
+      "url": "https://twitter.com/benjamincoe"
+    },
+    {
+      "name": "Nathan Zadoks",
+      "url": "https://github.com/nathan7"
+    },
+    {
+      "name": "Róbert Oroszi",
+      "email": "robert+gh@oroszi.net",
+      "url": "https://github.com/oroce"
+    },
+    {
+      "name": "Aurélio A. Heckert",
+      "url": "http://softwarelivre.org/aurium"
+    },
+    {
+      "name": "Guy Ellis",
+      "url": "http://www.guyellisrocks.com/"
+    },
+    {
+      "name": "fscherwi",
+      "url": "https://fscherwi.github.io"
+    },
+    {
+      "name": "rictic",
+      "url": "https://github.com/rictic"
+    },
+    {
+      "name": "Martin Jurča",
+      "url": "https://github.com/jurca"
+    },
+    {
+      "name": "Misery Lee",
+      "email": "miserylee@foxmail.com",
+      "url": "https://github.com/miserylee"
+    },
+    {
+      "name": "Clemens Wolff",
+      "url": "https://github.com/c-w"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "deep cloning of objects and arrays",
+  "devDependencies": {
+    "nodeunit": "~0.9.0"
+  },
+  "engines": {
+    "node": ">=0.8"
+  },
+  "homepage": "https://github.com/pvorb/node-clone#readme",
+  "license": "MIT",
+  "main": "clone.js",
+  "name": "clone",
+  "optionalDependencies": {},
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/pvorb/node-clone.git"
+  },
+  "scripts": {
+    "test": "nodeunit test.js"
+  },
+  "tags": [
+    "clone",
+    "object",
+    "array",
+    "function",
+    "date"
+  ],
+  "version": "2.1.2"
+}

node_modules/gulp-minify/node_modules/minimatch/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/gulp-minify/node_modules/minimatch/README.md

@@ -0,0 +1,209 @@
+# minimatch
+
+A minimal matching utility.
+
+[![Build Status](https://secure.travis-ci.org/isaacs/minimatch.svg)](http://travis-ci.org/isaacs/minimatch)
+
+
+This is the matching library used internally by npm.
+
+It works by converting glob expressions into JavaScript `RegExp`
+objects.
+
+## Usage
+
+```javascript
+var minimatch = require("minimatch")
+
+minimatch("bar.foo", "*.foo") // true!
+minimatch("bar.foo", "*.bar") // false!
+minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy!
+```
+
+## Features
+
+Supports these glob features:
+
+* Brace Expansion
+* Extended glob matching
+* "Globstar" `**` matching
+
+See:
+
+* `man sh`
+* `man bash`
+* `man 3 fnmatch`
+* `man 5 gitignore`
+
+## Minimatch Class
+
+Create a minimatch object by instantiating the `minimatch.Minimatch` class.
+
+```javascript
+var Minimatch = require("minimatch").Minimatch
+var mm = new Minimatch(pattern, options)
+```
+
+### Properties
+
+* `pattern` The original pattern the minimatch object represents.
+* `options` The options supplied to the constructor.
+* `set` A 2-dimensional array of regexp or string expressions.
+  Each row in the
+  array corresponds to a brace-expanded pattern.  Each item in the row
+  corresponds to a single path-part.  For example, the pattern
+  `{a,b/c}/d` would expand to a set of patterns like:
+
+        [ [ a, d ]
+        , [ b, c, d ] ]
+
+    If a portion of the pattern doesn't have any "magic" in it
+    (that is, it's something like `"foo"` rather than `fo*o?`), then it
+    will be left as a string rather than converted to a regular
+    expression.
+
+* `regexp` Created by the `makeRe` method.  A single regular expression
+  expressing the entire pattern.  This is useful in cases where you wish
+  to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
+* `negate` True if the pattern is negated.
+* `comment` True if the pattern is a comment.
+* `empty` True if the pattern is `""`.
+
+### Methods
+
+* `makeRe` Generate the `regexp` member if necessary, and return it.
+  Will return `false` if the pattern is invalid.
+* `match(fname)` Return true if the filename matches the pattern, or
+  false otherwise.
+* `matchOne(fileArray, patternArray, partial)` Take a `/`-split
+  filename, and match it against a single row in the `regExpSet`.  This
+  method is mainly for internal use, but is exposed so that it can be
+  used by a glob-walker that needs to avoid excessive filesystem calls.
+
+All other methods are internal, and will be called as necessary.
+
+### minimatch(path, pattern, options)
+
+Main export.  Tests a path against the pattern using the options.
+
+```javascript
+var isJS = minimatch(file, "*.js", { matchBase: true })
+```
+
+### minimatch.filter(pattern, options)
+
+Returns a function that tests its
+supplied argument, suitable for use with `Array.filter`.  Example:
+
+```javascript
+var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}))
+```
+
+### minimatch.match(list, pattern, options)
+
+Match against the list of
+files, in the style of fnmatch or glob.  If nothing is matched, and
+options.nonull is set, then return a list containing the pattern itself.
+
+```javascript
+var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}))
+```
+
+### minimatch.makeRe(pattern, options)
+
+Make a regular expression object from the pattern.
+
+## Options
+
+All options are `false` by default.
+
+### debug
+
+Dump a ton of stuff to stderr.
+
+### nobrace
+
+Do not expand `{a,b}` and `{1..3}` brace sets.
+
+### noglobstar
+
+Disable `**` matching against multiple folder names.
+
+### dot
+
+Allow patterns to match filenames starting with a period, even if
+the pattern does not explicitly have a period in that spot.
+
+Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot`
+is set.
+
+### noext
+
+Disable "extglob" style patterns like `+(a|b)`.
+
+### nocase
+
+Perform a case-insensitive match.
+
+### nonull
+
+When a match is not found by `minimatch.match`, return a list containing
+the pattern itself if this option is set.  When not set, an empty list
+is returned if there are no matches.
+
+### matchBase
+
+If set, then patterns without slashes will be matched
+against the basename of the path if it contains slashes.  For example,
+`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+
+### nocomment
+
+Suppress the behavior of treating `#` at the start of a pattern as a
+comment.
+
+### nonegate
+
+Suppress the behavior of treating a leading `!` character as negation.
+
+### flipNegate
+
+Returns from negate expressions the same as if they were not negated.
+(Ie, true on a hit, false on a miss.)
+
+
+## Comparisons to other fnmatch/glob implementations
+
+While strict compliance with the existing standards is a worthwhile
+goal, some discrepancies exist between minimatch and other
+implementations, and are intentional.
+
+If the pattern starts with a `!` character, then it is negated.  Set the
+`nonegate` flag to suppress this behavior, and treat leading `!`
+characters normally.  This is perhaps relevant if you wish to start the
+pattern with a negative extglob pattern like `!(a|B)`.  Multiple `!`
+characters at the start of a pattern will negate the pattern multiple
+times.
+
+If a pattern starts with `#`, then it is treated as a comment, and
+will not match anything.  Use `\#` to match a literal `#` at the
+start of a line, or set the `nocomment` flag to suppress this behavior.
+
+The double-star character `**` is supported by default, unless the
+`noglobstar` flag is set.  This is supported in the manner of bsdglob
+and bash 4.1, where `**` only has special significance if it is the only
+thing in a path part.  That is, `a/**/b` will match `a/x/y/b`, but
+`a/**b` will not.
+
+If an escaped pattern has no matches, and the `nonull` flag is set,
+then minimatch.match returns the pattern as-provided, rather than
+interpreting the character escapes.  For example,
+`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than
+`"*a?"`.  This is akin to setting the `nullglob` option in bash, except
+that it does not resolve escaped pattern characters.
+
+If brace expansion is not disabled, then it is performed before any
+other interpretation of the glob pattern.  Thus, a pattern like
+`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded
+**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are
+checked for validity.  Since those two are valid, matching proceeds.

node_modules/gulp-minify/node_modules/minimatch/minimatch.js

@@ -0,0 +1,923 @@
+module.exports = minimatch
+minimatch.Minimatch = Minimatch
+
+var path = { sep: '/' }
+try {
+  path = require('path')
+} catch (er) {}
+
+var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {}
+var expand = require('brace-expansion')
+
+var plTypes = {
+  '!': { open: '(?:(?!(?:', close: '))[^/]*?)'},
+  '?': { open: '(?:', close: ')?' },
+  '+': { open: '(?:', close: ')+' },
+  '*': { open: '(?:', close: ')*' },
+  '@': { open: '(?:', close: ')' }
+}
+
+// any single thing other than /
+// don't need to escape / when using new RegExp()
+var qmark = '[^/]'
+
+// * => any number of characters
+var star = qmark + '*?'
+
+// ** when dots are allowed.  Anything goes, except .. and .
+// not (^ or / followed by one or two dots followed by $ or /),
+// followed by anything, any number of times.
+var twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?'
+
+// not a ^ or / followed by a dot,
+// followed by anything, any number of times.
+var twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?'
+
+// characters that need to be escaped in RegExp.
+var reSpecials = charSet('().*{}+?[]^$\\!')
+
+// "abc" -> { a:true, b:true, c:true }
+function charSet (s) {
+  return s.split('').reduce(function (set, c) {
+    set[c] = true
+    return set
+  }, {})
+}
+
+// normalizes slashes.
+var slashSplit = /\/+/
+
+minimatch.filter = filter
+function filter (pattern, options) {
+  options = options || {}
+  return function (p, i, list) {
+    return minimatch(p, pattern, options)
+  }
+}
+
+function ext (a, b) {
+  a = a || {}
+  b = b || {}
+  var t = {}
+  Object.keys(b).forEach(function (k) {
+    t[k] = b[k]
+  })
+  Object.keys(a).forEach(function (k) {
+    t[k] = a[k]
+  })
+  return t
+}
+
+minimatch.defaults = function (def) {
+  if (!def || !Object.keys(def).length) return minimatch
+
+  var orig = minimatch
+
+  var m = function minimatch (p, pattern, options) {
+    return orig.minimatch(p, pattern, ext(def, options))
+  }
+
+  m.Minimatch = function Minimatch (pattern, options) {
+    return new orig.Minimatch(pattern, ext(def, options))
+  }
+
+  return m
+}
+
+Minimatch.defaults = function (def) {
+  if (!def || !Object.keys(def).length) return Minimatch
+  return minimatch.defaults(def).Minimatch
+}
+
+function minimatch (p, pattern, options) {
+  if (typeof pattern !== 'string') {
+    throw new TypeError('glob pattern string required')
+  }
+
+  if (!options) options = {}
+
+  // shortcut: comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    return false
+  }
+
+  // "" only matches ""
+  if (pattern.trim() === '') return p === ''
+
+  return new Minimatch(pattern, options).match(p)
+}
+
+function Minimatch (pattern, options) {
+  if (!(this instanceof Minimatch)) {
+    return new Minimatch(pattern, options)
+  }
+
+  if (typeof pattern !== 'string') {
+    throw new TypeError('glob pattern string required')
+  }
+
+  if (!options) options = {}
+  pattern = pattern.trim()
+
+  // windows support: need to use /, not \
+  if (path.sep !== '/') {
+    pattern = pattern.split(path.sep).join('/')
+  }
+
+  this.options = options
+  this.set = []
+  this.pattern = pattern
+  this.regexp = null
+  this.negate = false
+  this.comment = false
+  this.empty = false
+
+  // make the set of regexps etc.
+  this.make()
+}
+
+Minimatch.prototype.debug = function () {}
+
+Minimatch.prototype.make = make
+function make () {
+  // don't do it more than once.
+  if (this._made) return
+
+  var pattern = this.pattern
+  var options = this.options
+
+  // empty patterns and comments match nothing.
+  if (!options.nocomment && pattern.charAt(0) === '#') {
+    this.comment = true
+    return
+  }
+  if (!pattern) {
+    this.empty = true
+    return
+  }
+
+  // step 1: figure out negation, etc.
+  this.parseNegate()
+
+  // step 2: expand braces
+  var set = this.globSet = this.braceExpand()
+
+  if (options.debug) this.debug = console.error
+
+  this.debug(this.pattern, set)
+
+  // step 3: now we have a set, so turn each one into a series of path-portion
+  // matching patterns.
+  // These will be regexps, except in the case of "**", which is
+  // set to the GLOBSTAR object for globstar behavior,
+  // and will not contain any / characters
+  set = this.globParts = set.map(function (s) {
+    return s.split(slashSplit)
+  })
+
+  this.debug(this.pattern, set)
+
+  // glob --> regexps
+  set = set.map(function (s, si, set) {
+    return s.map(this.parse, this)
+  }, this)
+
+  this.debug(this.pattern, set)
+
+  // filter out everything that didn't compile properly.
+  set = set.filter(function (s) {
+    return s.indexOf(false) === -1
+  })
+
+  this.debug(this.pattern, set)
+
+  this.set = set
+}
+
+Minimatch.prototype.parseNegate = parseNegate
+function parseNegate () {
+  var pattern = this.pattern
+  var negate = false
+  var options = this.options
+  var negateOffset = 0
+
+  if (options.nonegate) return
+
+  for (var i = 0, l = pattern.length
+    ; i < l && pattern.charAt(i) === '!'
+    ; i++) {
+    negate = !negate
+    negateOffset++
+  }
+
+  if (negateOffset) this.pattern = pattern.substr(negateOffset)
+  this.negate = negate
+}
+
+// Brace expansion:
+// a{b,c}d -> abd acd
+// a{b,}c -> abc ac
+// a{0..3}d -> a0d a1d a2d a3d
+// a{b,c{d,e}f}g -> abg acdfg acefg
+// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg
+//
+// Invalid sets are not expanded.
+// a{2..}b -> a{2..}b
+// a{b}c -> a{b}c
+minimatch.braceExpand = function (pattern, options) {
+  return braceExpand(pattern, options)
+}
+
+Minimatch.prototype.braceExpand = braceExpand
+
+function braceExpand (pattern, options) {
+  if (!options) {
+    if (this instanceof Minimatch) {
+      options = this.options
+    } else {
+      options = {}
+    }
+  }
+
+  pattern = typeof pattern === 'undefined'
+    ? this.pattern : pattern
+
+  if (typeof pattern === 'undefined') {
+    throw new TypeError('undefined pattern')
+  }
+
+  if (options.nobrace ||
+    !pattern.match(/\{.*\}/)) {
+    // shortcut. no need to expand.
+    return [pattern]
+  }
+
+  return expand(pattern)
+}
+
+// parse a component of the expanded set.
+// At this point, no pattern may contain "/" in it
+// so we're going to return a 2d array, where each entry is the full
+// pattern, split on '/', and then turned into a regular expression.
+// A regexp is made at the end which joins each array with an
+// escaped /, and another full one which joins each regexp with |.
+//
+// Following the lead of Bash 4.1, note that "**" only has special meaning
+// when it is the *only* thing in a path portion.  Otherwise, any series
+// of * is equivalent to a single *.  Globstar behavior is enabled by
+// default, and can be disabled by setting options.noglobstar.
+Minimatch.prototype.parse = parse
+var SUBPARSE = {}
+function parse (pattern, isSub) {
+  if (pattern.length > 1024 * 64) {
+    throw new TypeError('pattern is too long')
+  }
+
+  var options = this.options
+
+  // shortcuts
+  if (!options.noglobstar && pattern === '**') return GLOBSTAR
+  if (pattern === '') return ''
+
+  var re = ''
+  var hasMagic = !!options.nocase
+  var escaping = false
+  // ? => one single character
+  var patternListStack = []
+  var negativeLists = []
+  var stateChar
+  var inClass = false
+  var reClassStart = -1
+  var classStart = -1
+  // . and .. never match anything that doesn't start with .,
+  // even when options.dot is set.
+  var patternStart = pattern.charAt(0) === '.' ? '' // anything
+  // not (start or / followed by . or .. followed by / or end)
+  : options.dot ? '(?!(?:^|\\\/)\\.{1,2}(?:$|\\\/))'
+  : '(?!\\.)'
+  var self = this
+
+  function clearStateChar () {
+    if (stateChar) {
+      // we had some state-tracking character
+      // that wasn't consumed by this pass.
+      switch (stateChar) {
+        case '*':
+          re += star
+          hasMagic = true
+        break
+        case '?':
+          re += qmark
+          hasMagic = true
+        break
+        default:
+          re += '\\' + stateChar
+        break
+      }
+      self.debug('clearStateChar %j %j', stateChar, re)
+      stateChar = false
+    }
+  }
+
+  for (var i = 0, len = pattern.length, c
+    ; (i < len) && (c = pattern.charAt(i))
+    ; i++) {
+    this.debug('%s\t%s %s %j', pattern, i, re, c)
+
+    // skip over any that are escaped.
+    if (escaping && reSpecials[c]) {
+      re += '\\' + c
+      escaping = false
+      continue
+    }
+
+    switch (c) {
+      case '/':
+        // completely not allowed, even escaped.
+        // Should already be path-split by now.
+        return false
+
+      case '\\':
+        clearStateChar()
+        escaping = true
+      continue
+
+      // the various stateChar values
+      // for the "extglob" stuff.
+      case '?':
+      case '*':
+      case '+':
+      case '@':
+      case '!':
+        this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c)
+
+        // all of those are literals inside a class, except that
+        // the glob [!a] means [^a] in regexp
+        if (inClass) {
+          this.debug('  in class')
+          if (c === '!' && i === classStart + 1) c = '^'
+          re += c
+          continue
+        }
+
+        // if we already have a stateChar, then it means
+        // that there was something like ** or +? in there.
+        // Handle the stateChar, then proceed with this one.
+        self.debug('call clearStateChar %j', stateChar)
+        clearStateChar()
+        stateChar = c
+        // if extglob is disabled, then +(asdf|foo) isn't a thing.
+        // just clear the statechar *now*, rather than even diving into
+        // the patternList stuff.
+        if (options.noext) clearStateChar()
+      continue
+
+      case '(':
+        if (inClass) {
+          re += '('
+          continue
+        }
+
+        if (!stateChar) {
+          re += '\\('
+          continue
+        }
+
+        patternListStack.push({
+          type: stateChar,
+          start: i - 1,
+          reStart: re.length,
+          open: plTypes[stateChar].open,
+          close: plTypes[stateChar].close
+        })
+        // negation is (?:(?!js)[^/]*)
+        re += stateChar === '!' ? '(?:(?!(?:' : '(?:'
+        this.debug('plType %j %j', stateChar, re)
+        stateChar = false
+      continue
+
+      case ')':
+        if (inClass || !patternListStack.length) {
+          re += '\\)'
+          continue
+        }
+
+        clearStateChar()
+        hasMagic = true
+        var pl = patternListStack.pop()
+        // negation is (?:(?!js)[^/]*)
+        // The others are (?:<pattern>)<type>
+        re += pl.close
+        if (pl.type === '!') {
+          negativeLists.push(pl)
+        }
+        pl.reEnd = re.length
+      continue
+
+      case '|':
+        if (inClass || !patternListStack.length || escaping) {
+          re += '\\|'
+          escaping = false
+          continue
+        }
+
+        clearStateChar()
+        re += '|'
+      continue
+
+      // these are mostly the same in regexp and glob
+      case '[':
+        // swallow any state-tracking char before the [
+        clearStateChar()
+
+        if (inClass) {
+          re += '\\' + c
+          continue
+        }
+
+        inClass = true
+        classStart = i
+        reClassStart = re.length
+        re += c
+      continue
+
+      case ']':
+        //  a right bracket shall lose its special
+        //  meaning and represent itself in
+        //  a bracket expression if it occurs
+        //  first in the list.  -- POSIX.2 2.8.3.2
+        if (i === classStart + 1 || !inClass) {
+          re += '\\' + c
+          escaping = false
+          continue
+        }
+
+        // handle the case where we left a class open.
+        // "[z-a]" is valid, equivalent to "\[z-a\]"
+        if (inClass) {
+          // split where the last [ was, make sure we don't have
+          // an invalid re. if so, re-walk the contents of the
+          // would-be class to re-translate any characters that
+          // were passed through as-is
+          // TODO: It would probably be faster to determine this
+          // without a try/catch and a new RegExp, but it's tricky
+          // to do safely.  For now, this is safe and works.
+          var cs = pattern.substring(classStart + 1, i)
+          try {
+            RegExp('[' + cs + ']')
+          } catch (er) {
+            // not a valid class!
+            var sp = this.parse(cs, SUBPARSE)
+            re = re.substr(0, reClassStart) + '\\[' + sp[0] + '\\]'
+            hasMagic = hasMagic || sp[1]
+            inClass = false
+            continue
+          }
+        }
+
+        // finish up the class.
+        hasMagic = true
+        inClass = false
+        re += c
+      continue
+
+      default:
+        // swallow any state char that wasn't consumed
+        clearStateChar()
+
+        if (escaping) {
+          // no need
+          escaping = false
+        } else if (reSpecials[c]
+          && !(c === '^' && inClass)) {
+          re += '\\'
+        }
+
+        re += c
+
+    } // switch
+  } // for
+
+  // handle the case where we left a class open.
+  // "[abc" is valid, equivalent to "\[abc"
+  if (inClass) {
+    // split where the last [ was, and escape it
+    // this is a huge pita.  We now have to re-walk
+    // the contents of the would-be class to re-translate
+    // any characters that were passed through as-is
+    cs = pattern.substr(classStart + 1)
+    sp = this.parse(cs, SUBPARSE)
+    re = re.substr(0, reClassStart) + '\\[' + sp[0]
+    hasMagic = hasMagic || sp[1]
+  }
+
+  // handle the case where we had a +( thing at the *end*
+  // of the pattern.
+  // each pattern list stack adds 3 chars, and we need to go through
+  // and escape any | chars that were passed through as-is for the regexp.
+  // Go through and escape them, taking care not to double-escape any
+  // | chars that were already escaped.
+  for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
+    var tail = re.slice(pl.reStart + pl.open.length)
+    this.debug('setting tail', re, pl)
+    // maybe some even number of \, then maybe 1 \, followed by a |
+    tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, function (_, $1, $2) {
+      if (!$2) {
+        // the | isn't already escaped, so escape it.
+        $2 = '\\'
+      }
+
+      // need to escape all those slashes *again*, without escaping the
+      // one that we need for escaping the | character.  As it works out,
+      // escaping an even number of slashes can be done by simply repeating
+      // it exactly after itself.  That's why this trick works.
+      //
+      // I am sorry that you have to see this.
+      return $1 + $1 + $2 + '|'
+    })
+
+    this.debug('tail=%j\n   %s', tail, tail, pl, re)
+    var t = pl.type === '*' ? star
+      : pl.type === '?' ? qmark
+      : '\\' + pl.type
+
+    hasMagic = true
+    re = re.slice(0, pl.reStart) + t + '\\(' + tail
+  }
+
+  // handle trailing things that only matter at the very end.
+  clearStateChar()
+  if (escaping) {
+    // trailing \\
+    re += '\\\\'
+  }
+
+  // only need to apply the nodot start if the re starts with
+  // something that could conceivably capture a dot
+  var addPatternStart = false
+  switch (re.charAt(0)) {
+    case '.':
+    case '[':
+    case '(': addPatternStart = true
+  }
+
+  // Hack to work around lack of negative lookbehind in JS
+  // A pattern like: *.!(x).!(y|z) needs to ensure that a name
+  // like 'a.xyz.yz' doesn't match.  So, the first negative
+  // lookahead, has to look ALL the way ahead, to the end of
+  // the pattern.
+  for (var n = negativeLists.length - 1; n > -1; n--) {
+    var nl = negativeLists[n]
+
+    var nlBefore = re.slice(0, nl.reStart)
+    var nlFirst = re.slice(nl.reStart, nl.reEnd - 8)
+    var nlLast = re.slice(nl.reEnd - 8, nl.reEnd)
+    var nlAfter = re.slice(nl.reEnd)
+
+    nlLast += nlAfter
+
+    // Handle nested stuff like *(*.js|!(*.json)), where open parens
+    // mean that we should *not* include the ) in the bit that is considered
+    // "after" the negated section.
+    var openParensBefore = nlBefore.split('(').length - 1
+    var cleanAfter = nlAfter
+    for (i = 0; i < openParensBefore; i++) {
+      cleanAfter = cleanAfter.replace(/\)[+*?]?/, '')
+    }
+    nlAfter = cleanAfter
+
+    var dollar = ''
+    if (nlAfter === '' && isSub !== SUBPARSE) {
+      dollar = '$'
+    }
+    var newRe = nlBefore + nlFirst + nlAfter + dollar + nlLast
+    re = newRe
+  }
+
+  // if the re is not "" at this point, then we need to make sure
+  // it doesn't match against an empty path part.
+  // Otherwise a/* will match a/, which it should not.
+  if (re !== '' && hasMagic) {
+    re = '(?=.)' + re
+  }
+
+  if (addPatternStart) {
+    re = patternStart + re
+  }
+
+  // parsing just a piece of a larger pattern.
+  if (isSub === SUBPARSE) {
+    return [re, hasMagic]
+  }
+
+  // skip the regexp for non-magical patterns
+  // unescape anything in it, though, so that it'll be
+  // an exact match against a file etc.
+  if (!hasMagic) {
+    return globUnescape(pattern)
+  }
+
+  var flags = options.nocase ? 'i' : ''
+  try {
+    var regExp = new RegExp('^' + re + '$', flags)
+  } catch (er) {
+    // If it was an invalid regular expression, then it can't match
+    // anything.  This trick looks for a character after the end of
+    // the string, which is of course impossible, except in multi-line
+    // mode, but it's not a /m regex.
+    return new RegExp('$.')
+  }
+
+  regExp._glob = pattern
+  regExp._src = re
+
+  return regExp
+}
+
+minimatch.makeRe = function (pattern, options) {
+  return new Minimatch(pattern, options || {}).makeRe()
+}
+
+Minimatch.prototype.makeRe = makeRe
+function makeRe () {
+  if (this.regexp || this.regexp === false) return this.regexp
+
+  // at this point, this.set is a 2d array of partial
+  // pattern strings, or "**".
+  //
+  // It's better to use .match().  This function shouldn't
+  // be used, really, but it's pretty convenient sometimes,
+  // when you just want to work with a regex.
+  var set = this.set
+
+  if (!set.length) {
+    this.regexp = false
+    return this.regexp
+  }
+  var options = this.options
+
+  var twoStar = options.noglobstar ? star
+    : options.dot ? twoStarDot
+    : twoStarNoDot
+  var flags = options.nocase ? 'i' : ''
+
+  var re = set.map(function (pattern) {
+    return pattern.map(function (p) {
+      return (p === GLOBSTAR) ? twoStar
+      : (typeof p === 'string') ? regExpEscape(p)
+      : p._src
+    }).join('\\\/')
+  }).join('|')
+
+  // must match entire pattern
+  // ending in a * or ** will make it less strict.
+  re = '^(?:' + re + ')$'
+
+  // can match anything, as long as it's not this.
+  if (this.negate) re = '^(?!' + re + ').*$'
+
+  try {
+    this.regexp = new RegExp(re, flags)
+  } catch (ex) {
+    this.regexp = false
+  }
+  return this.regexp
+}
+
+minimatch.match = function (list, pattern, options) {
+  options = options || {}
+  var mm = new Minimatch(pattern, options)
+  list = list.filter(function (f) {
+    return mm.match(f)
+  })
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern)
+  }
+  return list
+}
+
+Minimatch.prototype.match = match
+function match (f, partial) {
+  this.debug('match', f, this.pattern)
+  // short-circuit in the case of busted things.
+  // comments, etc.
+  if (this.comment) return false
+  if (this.empty) return f === ''
+
+  if (f === '/' && partial) return true
+
+  var options = this.options
+
+  // windows: need to use /, not \
+  if (path.sep !== '/') {
+    f = f.split(path.sep).join('/')
+  }
+
+  // treat the test path as a set of pathparts.
+  f = f.split(slashSplit)
+  this.debug(this.pattern, 'split', f)
+
+  // just ONE of the pattern sets in this.set needs to match
+  // in order for it to be valid.  If negating, then just one
+  // match means that we have failed.
+  // Either way, return on the first hit.
+
+  var set = this.set
+  this.debug(this.pattern, 'set', set)
+
+  // Find the basename of the path by looking for the last non-empty segment
+  var filename
+  var i
+  for (i = f.length - 1; i >= 0; i--) {
+    filename = f[i]
+    if (filename) break
+  }
+
+  for (i = 0; i < set.length; i++) {
+    var pattern = set[i]
+    var file = f
+    if (options.matchBase && pattern.length === 1) {
+      file = [filename]
+    }
+    var hit = this.matchOne(file, pattern, partial)
+    if (hit) {
+      if (options.flipNegate) return true
+      return !this.negate
+    }
+  }
+
+  // didn't get any hits.  this is success if it's a negative
+  // pattern, failure otherwise.
+  if (options.flipNegate) return false
+  return this.negate
+}
+
+// set partial to true to test if, for example,
+// "/a/b" matches the start of "/*/b/*/d"
+// Partial means, if you run out of file before you run
+// out of pattern, then that's fine, as long as all
+// the parts match.
+Minimatch.prototype.matchOne = function (file, pattern, partial) {
+  var options = this.options
+
+  this.debug('matchOne',
+    { 'this': this, file: file, pattern: pattern })
+
+  this.debug('matchOne', file.length, pattern.length)
+
+  for (var fi = 0,
+      pi = 0,
+      fl = file.length,
+      pl = pattern.length
+      ; (fi < fl) && (pi < pl)
+      ; fi++, pi++) {
+    this.debug('matchOne loop')
+    var p = pattern[pi]
+    var f = file[fi]
+
+    this.debug(pattern, p, f)
+
+    // should be impossible.
+    // some invalid regexp stuff in the set.
+    if (p === false) return false
+
+    if (p === GLOBSTAR) {
+      this.debug('GLOBSTAR', [pattern, p, f])
+
+      // "**"
+      // a/**/b/**/c would match the following:
+      // a/b/x/y/z/c
+      // a/x/y/z/b/c
+      // a/b/x/b/x/c
+      // a/b/c
+      // To do this, take the rest of the pattern after
+      // the **, and see if it would match the file remainder.
+      // If so, return success.
+      // If not, the ** "swallows" a segment, and try again.
+      // This is recursively awful.
+      //
+      // a/**/b/**/c matching a/b/x/y/z/c
+      // - a matches a
+      // - doublestar
+      //   - matchOne(b/x/y/z/c, b/**/c)
+      //     - b matches b
+      //     - doublestar
+      //       - matchOne(x/y/z/c, c) -> no
+      //       - matchOne(y/z/c, c) -> no
+      //       - matchOne(z/c, c) -> no
+      //       - matchOne(c, c) yes, hit
+      var fr = fi
+      var pr = pi + 1
+      if (pr === pl) {
+        this.debug('** at the end')
+        // a ** at the end will just swallow the rest.
+        // We have found a match.
+        // however, it will not swallow /.x, unless
+        // options.dot is set.
+        // . and .. are *never* matched by **, for explosively
+        // exponential reasons.
+        for (; fi < fl; fi++) {
+          if (file[fi] === '.' || file[fi] === '..' ||
+            (!options.dot && file[fi].charAt(0) === '.')) return false
+        }
+        return true
+      }
+
+      // ok, let's see if we can swallow whatever we can.
+      while (fr < fl) {
+        var swallowee = file[fr]
+
+        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
+
+        // XXX remove this slice.  Just pass the start index.
+        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
+          this.debug('globstar found match!', fr, fl, swallowee)
+          // found a match.
+          return true
+        } else {
+          // can't swallow "." or ".." ever.
+          // can only swallow ".foo" when explicitly asked.
+          if (swallowee === '.' || swallowee === '..' ||
+            (!options.dot && swallowee.charAt(0) === '.')) {
+            this.debug('dot detected!', file, fr, pattern, pr)
+            break
+          }
+
+          // ** swallows a segment, and continue.
+          this.debug('globstar swallow a segment, and continue')
+          fr++
+        }
+      }
+
+      // no match was found.
+      // However, in partial mode, we can't say this is necessarily over.
+      // If there's more *pattern* left, then
+      if (partial) {
+        // ran out of file
+        this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
+        if (fr === fl) return true
+      }
+      return false
+    }
+
+    // something other than **
+    // non-magic patterns just have to match exactly
+    // patterns with magic have been turned into regexps.
+    var hit
+    if (typeof p === 'string') {
+      if (options.nocase) {
+        hit = f.toLowerCase() === p.toLowerCase()
+      } else {
+        hit = f === p
+      }
+      this.debug('string match', p, f, hit)
+    } else {
+      hit = f.match(p)
+      this.debug('pattern match', p, f, hit)
+    }
+
+    if (!hit) return false
+  }
+
+  // Note: ending in / means that we'll get a final ""
+  // at the end of the pattern.  This can only match a
+  // corresponding "" at the end of the file.
+  // If the file ends in /, then it can only match a
+  // a pattern that ends in /, unless the pattern just
+  // doesn't have any more for it. But, a/b/ should *not*
+  // match "a/b/*", even though "" matches against the
+  // [^/]*? pattern, except in partial mode, where it might
+  // simply not be reached yet.
+  // However, a/b/ should still satisfy a/*
+
+  // now either we fell off the end of the pattern, or we're done.
+  if (fi === fl && pi === pl) {
+    // ran out of pattern and filename at the same time.
+    // an exact hit!
+    return true
+  } else if (fi === fl) {
+    // ran out of file, but still had pattern left.
+    // this is ok if we're doing the match as part of
+    // a glob fs traversal.
+    return partial
+  } else if (pi === pl) {
+    // ran out of pattern, still have file left.
+    // this is only acceptable if we're on the very last
+    // empty segment of a file with a trailing slash.
+    // a/* should match a/b/
+    var emptyFileEnd = (fi === fl - 1) && (file[fi] === '')
+    return emptyFileEnd
+  }
+
+  // should be unreachable.
+  throw new Error('wtf?')
+}
+
+// replace stuff like \* with *
+function globUnescape (s) {
+  return s.replace(/\\(.)/g, '$1')
+}
+
+function regExpEscape (s) {
+  return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')
+}

node_modules/gulp-minify/node_modules/minimatch/package.json

@@ -0,0 +1,63 @@
+{
+  "_from": "minimatch@^3.0.2",
+  "_id": "minimatch@3.0.4",
+  "_inBundle": false,
+  "_integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==",
+  "_location": "/gulp-minify/minimatch",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "minimatch@^3.0.2",
+    "name": "minimatch",
+    "escapedName": "minimatch",
+    "rawSpec": "^3.0.2",
+    "saveSpec": null,
+    "fetchSpec": "^3.0.2"
+  },
+  "_requiredBy": [
+    "/gulp-minify"
+  ],
+  "_resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz",
+  "_shasum": "5166e286457f03306064be5497e8dbb0c3d32083",
+  "_spec": "minimatch@^3.0.2",
+  "_where": "/var/www/html/autocompletion/node_modules/gulp-minify",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me"
+  },
+  "bugs": {
+    "url": "https://github.com/isaacs/minimatch/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "brace-expansion": "^1.1.7"
+  },
+  "deprecated": false,
+  "description": "a glob matcher in javascript",
+  "devDependencies": {
+    "tap": "^10.3.2"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "files": [
+    "minimatch.js"
+  ],
+  "homepage": "https://github.com/isaacs/minimatch#readme",
+  "license": "ISC",
+  "main": "minimatch.js",
+  "name": "minimatch",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/minimatch.git"
+  },
+  "scripts": {
+    "postpublish": "git push origin --all; git push origin --tags",
+    "postversion": "npm publish",
+    "preversion": "npm test",
+    "test": "tap test/*.js --cov"
+  },
+  "version": "3.0.4"
+}

node_modules/gulp-minify/node_modules/replace-ext/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blaine Bublitz <blaine.bublitz@gmail.com>, Eric Schoffstall <yo@contra.io> 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-minify/node_modules/replace-ext/README.md

@@ -0,0 +1,50 @@
+<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>
+
+# replace-ext
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url]
+
+Replaces a file extension with another one.
+
+## Usage
+
+```js
+var replaceExt = require('replace-ext');
+
+var path = '/some/dir/file.js';
+var newPath = replaceExt(path, '.coffee');
+
+console.log(newPath); // /some/dir/file.coffee
+```
+
+## API
+
+### `replaceExt(path, extension)`
+
+Replaces the extension from `path` with `extension` and returns the updated path string.
+
+Does not replace the extension if `path` is not a string or is empty.
+
+## License
+
+MIT
+
+[downloads-image]: http://img.shields.io/npm/dm/replace-ext.svg
+[npm-url]: https://www.npmjs.com/package/replace-ext
+[npm-image]: http://img.shields.io/npm/v/replace-ext.svg
+
+[travis-url]: https://travis-ci.org/gulpjs/replace-ext
+[travis-image]: http://img.shields.io/travis/gulpjs/replace-ext.svg?label=travis-ci
+
+[appveyor-url]: https://ci.appveyor.com/project/gulpjs/replace-ext
+[appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/replace-ext.svg?label=appveyor
+
+[coveralls-url]: https://coveralls.io/r/gulpjs/replace-ext
+[coveralls-image]: http://img.shields.io/coveralls/gulpjs/replace-ext/master.svg
+
+[gitter-url]: https://gitter.im/gulpjs/gulp
+[gitter-image]: https://badges.gitter.im/gulpjs/gulp.svg

node_modules/gulp-minify/node_modules/replace-ext/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var path = require('path');
+
+function replaceExt(npath, ext) {
+  if (typeof npath !== 'string') {
+    return npath;
+  }
+
+  if (npath.length === 0) {
+    return npath;
+  }
+
+  var nFileName = path.basename(npath, path.extname(npath)) + ext;
+  return path.join(path.dirname(npath), nFileName);
+}
+
+module.exports = replaceExt;

node_modules/gulp-minify/node_modules/replace-ext/package.json

@@ -0,0 +1,86 @@
+{
+  "_from": "replace-ext@^1.0.0",
+  "_id": "replace-ext@1.0.0",
+  "_inBundle": false,
+  "_integrity": "sha1-3mMSg3P8v3w8z6TeWkgMRaZ5WOs=",
+  "_location": "/gulp-minify/replace-ext",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "replace-ext@^1.0.0",
+    "name": "replace-ext",
+    "escapedName": "replace-ext",
+    "rawSpec": "^1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "^1.0.0"
+  },
+  "_requiredBy": [
+    "/gulp-minify/vinyl"
+  ],
+  "_resolved": "https://registry.npmjs.org/replace-ext/-/replace-ext-1.0.0.tgz",
+  "_shasum": "de63128373fcbf7c3ccfa4de5a480c45a67958eb",
+  "_spec": "replace-ext@^1.0.0",
+  "_where": "/var/www/html/autocompletion/node_modules/gulp-minify/node_modules/vinyl",
+  "author": {
+    "name": "Gulp Team",
+    "email": "team@gulpjs.com",
+    "url": "http://gulpjs.com/"
+  },
+  "bugs": {
+    "url": "https://github.com/gulpjs/replace-ext/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Eric Schoffstall",
+      "email": "yo@contra.io"
+    },
+    {
+      "name": "Blaine Bublitz",
+      "email": "blaine.bublitz@gmail.com"
+    }
+  ],
+  "dependencies": {},
+  "deprecated": false,
+  "description": "Replaces a file extension with another one",
+  "devDependencies": {
+    "eslint": "^1.10.3",
+    "eslint-config-gulp": "^2.0.0",
+    "expect": "^1.16.0",
+    "istanbul": "^0.4.3",
+    "istanbul-coveralls": "^1.0.3",
+    "jscs": "^2.3.5",
+    "jscs-preset-gulp": "^1.0.0",
+    "mocha": "^2.4.5"
+  },
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "files": [
+    "LICENSE",
+    "index.js"
+  ],
+  "homepage": "https://github.com/gulpjs/replace-ext#readme",
+  "keywords": [
+    "gulp",
+    "extensions",
+    "filepath",
+    "basename"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "replace-ext",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gulpjs/replace-ext.git"
+  },
+  "scripts": {
+    "cover": "istanbul cover node_modules/mocha/bin/_mocha --report lcovonly",
+    "coveralls": "npm run cover && istanbul-coveralls",
+    "lint": "eslint . && jscs index.js test/",
+    "pretest": "npm run lint",
+    "test": "mocha --async-only"
+  },
+  "version": "1.0.0"
+}

node_modules/gulp-minify/node_modules/vinyl/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Blaine Bublitz <blaine.bublitz@gmail.com>, Eric Schoffstall <yo@contra.io> 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-minify/node_modules/vinyl/README.md

@@ -0,0 +1,446 @@
+<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>
+
+# vinyl
+
+[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url]
+
+Virtual file format.
+
+## What is Vinyl?
+
+Vinyl is a very simple metadata object that describes a file. When you think of a file, two attributes come to mind: `path` and `contents`. These are the main attributes on a Vinyl object. A file does not necessarily represent something on your computer’s file system. You have files on S3, FTP, Dropbox, Box, CloudThingly.io and other services. Vinyl can be used to describe files from all of these sources.
+
+## What is a Vinyl Adapter?
+
+While Vinyl provides a clean way to describe a file, we also need a way to access these files. Each file source needs what I call a "Vinyl adapter". A Vinyl adapter simply exposes a `src(globs)` and a `dest(folder)` method. Each return a stream. The `src` stream produces Vinyl objects, and the `dest` stream consumes Vinyl objects. Vinyl adapters can expose extra methods that might be specific to their input/output medium, such as the `symlink` method [`vinyl-fs`][vinyl-fs] provides.
+
+## Usage
+
+```js
+var Vinyl = require('vinyl');
+
+var jsFile = new Vinyl({
+  cwd: '/',
+  base: '/test/',
+  path: '/test/file.js',
+  contents: new Buffer('var x = 123')
+});
+```
+
+## API
+
+### `new Vinyl([options])`
+
+The constructor is used to create a new instance of `Vinyl`. Each instance represents a separate file, directory or symlink.
+
+All internally managed paths (`cwd`, `base`, `path`, `history`) are normalized and have trailing separators removed. See [Normalization and concatenation][normalization] for more information.
+
+Options may be passed upon instantiation to create a file with specific properties.
+
+#### `options`
+
+Options are not mutated by the constructor.
+
+##### `options.cwd`
+
+The current working directory of the file.
+
+Type: `String`
+
+Default: `process.cwd()`
+
+##### `options.base`
+
+Used for calculating the `relative` property. This is typically where a glob starts.
+
+Type: `String`
+
+Default: `options.cwd`
+
+##### `options.path`
+
+The full path to the file.
+
+Type: `String`
+
+Default: `undefined`
+
+##### `options.history`
+
+Stores the path history. If `options.path` and `options.history` are both passed, `options.path` is appended to `options.history`. All `options.history` paths are normalized by the `file.path` setter.
+
+Type: `Array`
+
+Default: `[]` (or `[options.path]` if `options.path` is passed)
+
+##### `options.stat`
+
+The result of an `fs.stat` call. This is how you mark the file as a directory or symbolic link. See [isDirectory()][is-directory], [isSymbolic()][is-symbolic] and [fs.Stats][fs-stats] for more information.
+
+Type: [`fs.Stats`][fs-stats]
+
+Default: `undefined`
+
+##### `options.contents`
+
+The contents of the file.  If `options.contents` is a [`ReadableStream`][readable-stream], it is wrapped in a [`cloneable-readable`][cloneable-readable] stream.
+
+Type: [`ReadableStream`][readable-stream], [`Buffer`][buffer], or `null`
+
+Default: `null`
+
+##### `options.{custom}`
+
+Any other option properties will be directly assigned to the new Vinyl object.
+
+```js
+var Vinyl = require('vinyl');
+
+var file = new Vinyl({ foo: 'bar' });
+file.foo === 'bar'; // true
+```
+
+### Instance methods
+
+Each Vinyl object will have instance methods. Every method will be available but may return differently based on what properties were set upon instantiation or modified since.
+
+#### `file.isBuffer()`
+
+Returns `true` if the file contents are a [`Buffer`][buffer], otherwise `false`.
+
+#### `file.isStream()`
+
+Returns `true` if the file contents are a [`Stream`][stream], otherwise `false`.
+
+#### `file.isNull()`
+
+Returns `true` if the file contents are `null`, otherwise `false`.
+
+#### `file.isDirectory()`
+
+Returns `true` if the file represents a directory, otherwise `false`.
+
+A file is considered a directory when:
+
+- `file.isNull()` is `true`
+- `file.stat` is an object
+- `file.stat.isDirectory()` returns `true`
+
+When constructing a Vinyl object, pass in a valid [`fs.Stats`][fs-stats] object via `options.stat`. If you are mocking the [`fs.Stats`][fs-stats] object, you may need to stub the `isDirectory()` method.
+
+#### `file.isSymbolic()`
+
+Returns `true` if the file represents a symbolic link, otherwise `false`.
+
+A file is considered symbolic when:
+
+- `file.isNull()` is `true`
+- `file.stat` is an object
+- `file.stat.isSymbolicLink()` returns `true`
+
+When constructing a Vinyl object, pass in a valid [`fs.Stats`][fs-stats] object via `options.stat`. If you are mocking the [`fs.Stats`][fs-stats] object, you may need to stub the `isSymbolicLink()` method.
+
+#### `file.clone([options])`
+
+Returns a new Vinyl object with all attributes cloned.
+
+__By default custom attributes are cloned deeply.__
+
+If `options` or `options.deep` is `false`, custom attributes will not be cloned deeply.
+
+If `file.contents` is a [`Buffer`][buffer] and `options.contents` is `false`, the [`Buffer`][buffer] reference will be reused instead of copied.
+
+#### `file.inspect()`
+
+Returns a formatted-string interpretation of the Vinyl object. Automatically called by node's `console.log`.
+
+### Instance properties
+
+Each Vinyl object will have instance properties. Some may be unavailable based on what properties were set upon instantiation or modified since.
+
+#### `file.contents`
+
+Gets and sets the contents of the file. If set to a [`ReadableStream`][readable-stream], it is wrapped in a [`cloneable-readable`][cloneable-readable] stream.
+
+Throws when set to any value other than a [`ReadableStream`][readable-stream], a [`Buffer`][buffer] or `null`.
+
+Type: [`ReadableStream`][readable-stream], [`Buffer`][buffer], or `null`
+
+#### `file.cwd`
+
+Gets and sets current working directory. Will always be normalized and have trailing separators removed.
+
+Throws when set to any value other than non-empty strings.
+
+Type: `String`
+
+#### `file.base`
+
+Gets and sets base directory. Used for relative pathing (typically where a glob starts).
+When `null` or `undefined`, it simply proxies the `file.cwd` property. Will always be normalized and have trailing separators removed.
+
+Throws when set to any value other than non-empty strings or `null`/`undefined`.
+
+Type: `String`
+
+#### `file.path`
+
+Gets and sets the absolute pathname string or `undefined`. Setting to a different value appends the new path to `file.history`. If set to the same value as the current path, it is ignored. All new values are normalized and have trailing separators removed.
+
+Throws when set to any value other than a string.
+
+Type: `String`
+
+#### `file.history`
+
+Array of `file.path` values the Vinyl object has had, from `file.history[0]` (original) through `file.history[file.history.length - 1]` (current). `file.history` and its elements should normally be treated as read-only and only altered indirectly by setting `file.path`.
+
+Type: `Array`
+
+#### `file.relative`
+
+Gets the result of `path.relative(file.base, file.path)`.
+
+Throws when set or when `file.path` is not set.
+
+Type: `String`
+
+Example:
+
+```js
+var file = new File({
+  cwd: '/',
+  base: '/test/',
+  path: '/test/file.js'
+});
+
+console.log(file.relative); // file.js
+```
+
+#### `file.dirname`
+
+Gets and sets the dirname of `file.path`. Will always be normalized and have trailing separators removed.
+
+Throws when `file.path` is not set.
+
+Type: `String`
+
+Example:
+
+```js
+var file = new File({
+  cwd: '/',
+  base: '/test/',
+  path: '/test/file.js'
+});
+
+console.log(file.dirname); // /test
+
+file.dirname = '/specs';
+
+console.log(file.dirname); // /specs
+console.log(file.path); // /specs/file.js
+```
+
+#### `file.basename`
+
+Gets and sets the basename of `file.path`.
+
+Throws when `file.path` is not set.
+
+Type: `String`
+
+Example:
+
+```js
+var file = new File({
+  cwd: '/',
+  base: '/test/',
+  path: '/test/file.js'
+});
+
+console.log(file.basename); // file.js
+
+file.basename = 'file.txt';
+
+console.log(file.basename); // file.txt
+console.log(file.path); // /test/file.txt
+```
+
+#### `file.stem`
+
+Gets and sets stem (filename without suffix) of `file.path`.
+
+Throws when `file.path` is not set.
+
+Type: `String`
+
+Example:
+
+```js
+var file = new File({
+  cwd: '/',
+  base: '/test/',
+  path: '/test/file.js'
+});
+
+console.log(file.stem); // file
+
+file.stem = 'foo';
+
+console.log(file.stem); // foo
+console.log(file.path); // /test/foo.js
+```
+
+#### `file.extname`
+
+Gets and sets extname of `file.path`.
+
+Throws when `file.path` is not set.
+
+Type: `String`
+
+Example:
+
+```js
+var file = new File({
+  cwd: '/',
+  base: '/test/',
+  path: '/test/file.js'
+});
+
+console.log(file.extname); // .js
+
+file.extname = '.txt';
+
+console.log(file.extname); // .txt
+console.log(file.path); // /test/file.txt
+```
+
+#### `file.symlink`
+
+Gets and sets the path where the file points to if it's a symbolic link. Will always be normalized and have trailing separators removed.
+
+Throws when set to any value other than a string.
+
+Type: `String`
+
+### `Vinyl.isVinyl(file)`
+
+Static method used for checking if an object is a Vinyl file. Use this method instead of `instanceof`.
+
+Takes an object and returns `true` if it is a Vinyl file, otherwise returns `false`.
+
+__Note: This method uses an internal flag that some older versions of Vinyl didn't expose.__
+
+Example:
+
+```js
+var Vinyl = require('vinyl');
+
+var file = new Vinyl();
+var notAFile = {};
+
+Vinyl.isVinyl(file); // true
+Vinyl.isVinyl(notAFile); // false
+```
+
+### `Vinyl.isCustomProp(property)`
+
+Static method used by Vinyl when setting values inside the constructor or when copying properties in `file.clone()`.
+
+Takes a string `property` and returns `true` if the property is not used internally, otherwise returns `false`.
+
+This method is useful for inheritting from the Vinyl constructor. Read more in [Extending Vinyl][extending-vinyl].
+
+Example:
+
+```js
+var Vinyl = require('vinyl');
+
+Vinyl.isCustomProp('sourceMap'); // true
+Vinyl.isCustomProp('path'); // false -> internal getter/setter
+```
+
+## Normalization and concatenation
+
+Since all properties are normalized in their setters, you can just concatenate with `/`, and normalization takes care of it properly on all platforms.
+
+Example:
+
+```js
+var file = new File();
+file.path = '/' + 'test' + '/' + 'foo.bar';
+
+console.log(file.path);
+// posix => /test/foo.bar
+// win32 => \\test\\foo.bar
+```
+
+But never concatenate with `\`, since that is a valid filename character on posix system.
+
+## Extending Vinyl
+
+When extending Vinyl into your own class with extra features, you need to think about a few things.
+
+When you have your own properties that are managed internally, you need to extend the static `isCustomProp` method to return `false` when one of these properties is queried.
+
+```js
+var Vinyl = require('vinyl');
+
+var builtInProps = ['foo', '_foo'];
+
+class SuperFile extends Vinyl {
+  constructor(options) {
+    super(options);
+    this._foo = 'example internal read-only value';
+  }
+
+  get foo() {
+    return this._foo;
+  }
+
+  static isCustomProp(name) {
+    return super.isCustomProp(name) && builtInProps.indexOf(name) === -1;
+  }
+}
+```
+
+This makes properties `foo` and `_foo` ignored when cloning, and when passed in options to `constructor(options)` so they don't get assigned to the new object.
+
+Same goes for `clone()`. If you have your own internal stuff that needs special handling during cloning, you should extend it to do so.
+
+## License
+
+MIT
+
+[is-symbolic]: #issymbolic
+[is-directory]: #isdirectory
+[normalization]: #normalization-and-concatenation
+[extending-vinyl]: #extending-vinyl
+[stream]: https://nodejs.org/api/stream.html#stream_stream
+[readable-stream]: https://nodejs.org/api/stream.html#stream_readable_streams
+[buffer]: https://nodejs.org/api/buffer.html#buffer_class_buffer
+[fs-stats]: http://nodejs.org/api/fs.html#fs_class_fs_stats
+[vinyl-fs]: https://github.com/gulpjs/vinyl-fs
+[cloneable-readable]: https://github.com/mcollina/cloneable-readable
+
+[downloads-image]: http://img.shields.io/npm/dm/vinyl.svg
+[npm-url]: https://www.npmjs.com/package/vinyl
+[npm-image]: http://img.shields.io/npm/v/vinyl.svg
+
+[travis-url]: https://travis-ci.org/gulpjs/vinyl
+[travis-image]: http://img.shields.io/travis/gulpjs/vinyl.svg?label=travis-ci
+
+[appveyor-url]: https://ci.appveyor.com/project/gulpjs/vinyl
+[appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/vinyl.svg?label=appveyor
+
+[coveralls-url]: https://coveralls.io/r/gulpjs/vinyl
+[coveralls-image]: http://img.shields.io/coveralls/gulpjs/vinyl/master.svg
+
+[gitter-url]: https://gitter.im/gulpjs/gulp
+[gitter-image]: https://badges.gitter.im/gulpjs/gulp.svg

node_modules/gulp-minify/node_modules/vinyl/index.js

@@ -0,0 +1,334 @@
+'use strict';
+
+var path = require('path');
+var util = require('util');
+var isBuffer = require('buffer').Buffer.isBuffer;
+
+var clone = require('clone');
+var cloneable = require('cloneable-readable');
+var replaceExt = require('replace-ext');
+var cloneStats = require('clone-stats');
+var cloneBuffer = require('clone-buffer');
+var removeTrailingSep = require('remove-trailing-separator');
+
+var isStream = require('./lib/is-stream');
+var normalize = require('./lib/normalize');
+var inspectStream = require('./lib/inspect-stream');
+
+var builtInFields = [
+  '_contents', '_symlink', 'contents', 'stat', 'history', 'path',
+  '_base', 'base', '_cwd', 'cwd',
+];
+
+function File(file) {
+  var self = this;
+
+  if (!file) {
+    file = {};
+  }
+
+  // Stat = files stats object
+  this.stat = file.stat || null;
+
+  // Contents = stream, buffer, or null if not read
+  this.contents = file.contents || null;
+
+  // Replay path history to ensure proper normalization and trailing sep
+  var history = Array.prototype.slice.call(file.history || []);
+  if (file.path) {
+    history.push(file.path);
+  }
+  this.history = [];
+  history.forEach(function(path) {
+    self.path = path;
+  });
+
+  this.cwd = file.cwd || process.cwd();
+  this.base = file.base;
+
+  this._isVinyl = true;
+
+  this._symlink = null;
+
+  // Set custom properties
+  Object.keys(file).forEach(function(key) {
+    if (self.constructor.isCustomProp(key)) {
+      self[key] = file[key];
+    }
+  });
+}
+
+File.prototype.isBuffer = function() {
+  return isBuffer(this.contents);
+};
+
+File.prototype.isStream = function() {
+  return isStream(this.contents);
+};
+
+File.prototype.isNull = function() {
+  return (this.contents === null);
+};
+
+File.prototype.isDirectory = function() {
+  if (!this.isNull()) {
+    return false;
+  }
+
+  if (this.stat && typeof this.stat.isDirectory === 'function') {
+    return this.stat.isDirectory();
+  }
+
+  return false;
+};
+
+File.prototype.isSymbolic = function() {
+  if (!this.isNull()) {
+    return false;
+  }
+
+  if (this.stat && typeof this.stat.isSymbolicLink === 'function') {
+    return this.stat.isSymbolicLink();
+  }
+
+  return false;
+};
+
+File.prototype.clone = function(opt) {
+  var self = this;
+
+  if (typeof opt === 'boolean') {
+    opt = {
+      deep: opt,
+      contents: true,
+    };
+  } else if (!opt) {
+    opt = {
+      deep: true,
+      contents: true,
+    };
+  } else {
+    opt.deep = opt.deep === true;
+    opt.contents = opt.contents !== false;
+  }
+
+  // Clone our file contents
+  var contents;
+  if (this.isStream()) {
+    contents = this.contents.clone();
+  } else if (this.isBuffer()) {
+    contents = opt.contents ? cloneBuffer(this.contents) : this.contents;
+  }
+
+  var file = new this.constructor({
+    cwd: this.cwd,
+    base: this.base,
+    stat: (this.stat ? cloneStats(this.stat) : null),
+    history: this.history.slice(),
+    contents: contents,
+  });
+
+  // Clone our custom properties
+  Object.keys(this).forEach(function(key) {
+    if (self.constructor.isCustomProp(key)) {
+      file[key] = opt.deep ? clone(self[key], true) : self[key];
+    }
+  });
+  return file;
+};
+
+File.prototype.inspect = function() {
+  var inspect = [];
+
+  // Use relative path if possible
+  var filePath = this.path ? this.relative : null;
+
+  if (filePath) {
+    inspect.push('"' + filePath + '"');
+  }
+
+  if (this.isBuffer()) {
+    inspect.push(this.contents.inspect());
+  }
+
+  if (this.isStream()) {
+    inspect.push(inspectStream(this.contents));
+  }
+
+  return '<File ' + inspect.join(' ') + '>';
+};
+
+// Newer Node.js versions use this symbol for custom inspection.
+if (util.inspect.custom) {
+  File.prototype[util.inspect.custom] = File.prototype.inspect;
+}
+
+File.isCustomProp = function(key) {
+  return builtInFields.indexOf(key) === -1;
+};
+
+File.isVinyl = function(file) {
+  return (file && file._isVinyl === true) || false;
+};
+
+// Virtual attributes
+// Or stuff with extra logic
+Object.defineProperty(File.prototype, 'contents', {
+  get: function() {
+    return this._contents;
+  },
+  set: function(val) {
+    if (!isBuffer(val) && !isStream(val) && (val !== null)) {
+      throw new Error('File.contents can only be a Buffer, a Stream, or null.');
+    }
+
+    // Ask cloneable if the stream is a already a cloneable
+    // this avoid piping into many streams
+    // reducing the overhead of cloning
+    if (isStream(val) && !cloneable.isCloneable(val)) {
+      val = cloneable(val);
+    }
+
+    this._contents = val;
+  },
+});
+
+Object.defineProperty(File.prototype, 'cwd', {
+  get: function() {
+    return this._cwd;
+  },
+  set: function(cwd) {
+    if (!cwd || typeof cwd !== 'string') {
+      throw new Error('cwd must be a non-empty string.');
+    }
+    this._cwd = removeTrailingSep(normalize(cwd));
+  },
+});
+
+Object.defineProperty(File.prototype, 'base', {
+  get: function() {
+    return this._base || this._cwd;
+  },
+  set: function(base) {
+    if (base == null) {
+      delete this._base;
+      return;
+    }
+    if (typeof base !== 'string' || !base) {
+      throw new Error('base must be a non-empty string, or null/undefined.');
+    }
+    base = removeTrailingSep(normalize(base));
+    if (base !== this._cwd) {
+      this._base = base;
+    } else {
+      delete this._base;
+    }
+  },
+});
+
+// TODO: Should this be moved to vinyl-fs?
+Object.defineProperty(File.prototype, 'relative', {
+  get: function() {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get relative.');
+    }
+    return path.relative(this.base, this.path);
+  },
+  set: function() {
+    throw new Error('File.relative is generated from the base and path attributes. Do not modify it.');
+  },
+});
+
+Object.defineProperty(File.prototype, 'dirname', {
+  get: function() {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get dirname.');
+    }
+    return path.dirname(this.path);
+  },
+  set: function(dirname) {
+    if (!this.path) {
+      throw new Error('No path specified! Can not set dirname.');
+    }
+    this.path = path.join(dirname, this.basename);
+  },
+});
+
+Object.defineProperty(File.prototype, 'basename', {
+  get: function() {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get basename.');
+    }
+    return path.basename(this.path);
+  },
+  set: function(basename) {
+    if (!this.path) {
+      throw new Error('No path specified! Can not set basename.');
+    }
+    this.path = path.join(this.dirname, basename);
+  },
+});
+
+// Property for getting/setting stem of the filename.
+Object.defineProperty(File.prototype, 'stem', {
+  get: function() {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get stem.');
+    }
+    return path.basename(this.path, this.extname);
+  },
+  set: function(stem) {
+    if (!this.path) {
+      throw new Error('No path specified! Can not set stem.');
+    }
+    this.path = path.join(this.dirname, stem + this.extname);
+  },
+});
+
+Object.defineProperty(File.prototype, 'extname', {
+  get: function() {
+    if (!this.path) {
+      throw new Error('No path specified! Can not get extname.');
+    }
+    return path.extname(this.path);
+  },
+  set: function(extname) {
+    if (!this.path) {
+      throw new Error('No path specified! Can not set extname.');
+    }
+    this.path = replaceExt(this.path, extname);
+  },
+});
+
+Object.defineProperty(File.prototype, 'path', {
+  get: function() {
+    return this.history[this.history.length - 1];
+  },
+  set: function(path) {
+    if (typeof path !== 'string') {
+      throw new Error('path should be a string.');
+    }
+    path = removeTrailingSep(normalize(path));
+
+    // Record history only when path changed
+    if (path && path !== this.path) {
+      this.history.push(path);
+    }
+  },
+});
+
+Object.defineProperty(File.prototype, 'symlink', {
+  get: function() {
+    return this._symlink;
+  },
+  set: function(symlink) {
+    // TODO: should this set the mode to symbolic if set?
+    if (typeof symlink !== 'string') {
+      throw new Error('symlink should be a string');
+    }
+
+    this._symlink = removeTrailingSep(normalize(symlink));
+  },
+});
+
+module.exports = File;

node_modules/gulp-minify/node_modules/vinyl/lib/inspect-stream.js

@@ -0,0 +1,13 @@
+'use strict';
+
+function inspectStream(stream) {
+  var streamType = stream.constructor.name;
+  // Avoid StreamStream
+  if (streamType === 'Stream') {
+    streamType = '';
+  }
+
+  return '<' + streamType + 'Stream>';
+}
+
+module.exports = inspectStream;

node_modules/gulp-minify/node_modules/vinyl/lib/is-stream.js

@@ -0,0 +1,15 @@
+'use strict';
+
+function isStream(stream) {
+  if (!stream) {
+    return false;
+  }
+
+  if (typeof stream.pipe !== 'function') {
+    return false;
+  }
+
+  return true;
+}
+
+module.exports = isStream;

node_modules/gulp-minify/node_modules/vinyl/lib/normalize.js

@@ -0,0 +1,9 @@
+'use strict';
+
+var path = require('path');
+
+function normalize(str) {
+  return str === '' ? str : path.normalize(str);
+}
+
+module.exports = normalize;

node_modules/gulp-minify/node_modules/vinyl/package.json

@@ -0,0 +1,97 @@
+{
+  "_from": "vinyl@^2.1.0",
+  "_id": "vinyl@2.2.0",
+  "_inBundle": false,
+  "_integrity": "sha512-MBH+yP0kC/GQ5GwBqrTPTzEfiiLjta7hTtvQtbxBgTeSXsmKQRQecjibMbxIXzVT3Y9KJK+drOz1/k+vsu8Nkg==",
+  "_location": "/gulp-minify/vinyl",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "vinyl@^2.1.0",
+    "name": "vinyl",
+    "escapedName": "vinyl",
+    "rawSpec": "^2.1.0",
+    "saveSpec": null,
+    "fetchSpec": "^2.1.0"
+  },
+  "_requiredBy": [
+    "/gulp-minify"
+  ],
+  "_resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.2.0.tgz",
+  "_shasum": "d85b07da96e458d25b2ffe19fece9f2caa13ed86",
+  "_spec": "vinyl@^2.1.0",
+  "_where": "/var/www/html/autocompletion/node_modules/gulp-minify",
+  "author": {
+    "name": "Gulp Team",
+    "email": "team@gulpjs.com",
+    "url": "http://gulpjs.com/"
+  },
+  "bugs": {
+    "url": "https://github.com/gulpjs/vinyl/issues"
+  },
+  "bundleDependencies": false,
+  "contributors": [
+    {
+      "name": "Eric Schoffstall",
+      "email": "yo@contra.io"
+    },
+    {
+      "name": "Blaine Bublitz",
+      "email": "blaine.bublitz@gmail.com"
+    }
+  ],
+  "dependencies": {
+    "clone": "^2.1.1",
+    "clone-buffer": "^1.0.0",
+    "clone-stats": "^1.0.0",
+    "cloneable-readable": "^1.0.0",
+    "remove-trailing-separator": "^1.0.1",
+    "replace-ext": "^1.0.0"
+  },
+  "deprecated": false,
+  "description": "Virtual file format.",
+  "devDependencies": {
+    "eslint": "^1.7.3",
+    "eslint-config-gulp": "^2.0.0",
+    "expect": "^1.20.2",
+    "istanbul": "^0.4.3",
+    "istanbul-coveralls": "^1.0.3",
+    "jscs": "^2.3.5",
+    "jscs-preset-gulp": "^1.0.0",
+    "mississippi": "^1.2.0",
+    "mocha": "^2.4.5"
+  },
+  "engines": {
+    "node": ">= 0.10"
+  },
+  "files": [
+    "LICENSE",
+    "index.js",
+    "lib"
+  ],
+  "homepage": "https://github.com/gulpjs/vinyl#readme",
+  "keywords": [
+    "virtual",
+    "filesystem",
+    "file",
+    "directory",
+    "stat",
+    "path"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "vinyl",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gulpjs/vinyl.git"
+  },
+  "scripts": {
+    "cover": "istanbul cover _mocha --report lcovonly",
+    "coveralls": "npm run cover && istanbul-coveralls",
+    "lint": "eslint . && jscs index.js lib/ test/",
+    "pretest": "npm run lint",
+    "test": "mocha --async-only"
+  },
+  "version": "2.2.0"
+}