node_modules

3 files changed, 475 insertions, 0 deletions

diff --git a/node_modules/tapable/README.md b/node_modules/tapable/README.md
new file mode 100644
index 000000000..7a7d175ac
--- /dev/null
+++ b/node_modules/tapable/README.md
@@ -0,0 +1,141 @@
+# Tapable

+

+``` javascript

+var Tapable = require("tapable");

+```

+

+`Tapable` is a class for plugin binding and applying.

+

+Just extend it.

+

+``` javascript

+function MyClass() {

+	Tapable.call(this);

+}

+

+MyClass.prototype = Object.create(Tapable.prototype);

+

+MyClass.prototype.method = function() {};

+```

+

+Or mix it in.

+

+``` javascript

+function MyClass2() {

+	EventEmitter.call(this);

+	Tapable.call(this);

+}

+

+MyClass2.prototype = Object.create(EventEmitter.prototype);

+Tapable.mixin(MyClass2.prototype);

+

+MyClass2.prototype.method = function() {};

+```

+

+## Public functions

+

+### apply

+

+``` javascript

+void apply(plugins: Plugin...)

+```

+

+Attaches all plugins passed as arguments to the instance, by calling `apply` on them.

+

+### plugin

+

+``` javascript

+void plugin(names: string|string[], handler: Function)

+```

+

+`names` are the names (or a single name) of the plugin interfaces the class provides.

+

+`handler` is a callback function. The signature depends on the class. `this` is the instance of the class.

+

+## Protected functions

+

+### applyPlugins

+

+``` javascript

+void applyPlugins(name: string, args: any...)

+```

+

+Synchronous applies all registered handers for `name`. The handler functions are called with all args.

+

+### applyPluginsWaterfall

+

+``` javascript

+any applyPluginsWaterfall(name: string, init: any, args: any...)

+```

+

+Synchronous applies all registered handers for `name`. The handler functions are called with the return value of the previous handler and all args. For the first handler `init` is used and the return value of the last handler is return by `applyPluginsWaterfall`

+

+### applyPluginsAsync

+

+``` javascript

+void applyPluginsAsync(

+	name: string,

+	args: any...,

+	callback: (err?: Error) -> void

+)

+```

+

+Asynchronously applies all registered handers for `name`. The handler functions are called with all args and a callback function with the signature `(err?: Error) -> void`. The hander functions are called in order of registration.

+

+`callback` is called after all handlers are called.

+

+### applyPluginsBailResult

+

+``` javascript

+any applyPluginsBailResult(name: string, args: any...)

+```

+

+Synchronous applies all registered handers for `name`. The handler function are called with all args. If a handler function returns something `!== undefined`, the value is returned and no more handers are applied.

+

+### applyPluginsAsyncWaterfall

+

+``` javascript

+applyPluginsAsyncWaterfall(

+	name: string,

+	init: any,

+	callback: (err: Error, result: any) -> void

+)

+```

+

+Asynchronously applies all registered handers for `name`. The hander functions are called with the current value and a callback function with the signature `(err: Error, nextValue: any) -> void`. When called `nextValue` is the current value for the next handler. The current value for the first handler is `init`. After all handlers are applied, `callback` is called with the last value. If any handler passes a value for `err`, the `callback` is called with this error and no more handlers are called.

+

+### applyPluginsAsyncSeries

+

+``` javascript

+applyPluginsAsyncSeries(

+	name: string,

+	args: any...,

+	callback: (err: Error, result: any) -> void

+)

+```

+

+Asynchronously applies all registered handers for `name`. The hander functions are called with all `args` and a callback function with the signature `(err: Error) -> void`. The handers are called in series, one at a time. After all handlers are applied, `callback` is called. If any handler passes a value for `err`, the `callback` is called with this error and no more handlers are called.

+

+### applyPluginsParallel

+

+``` javascript

+applyPluginsParallel(

+	name: string,

+	args: any...,

+	callback: (err?: Error) -> void

+)

+```

+

+Applies all registered handlers for `name` parallel. The handler functions are called with all args and a callback function with the signature `(err?: Error) -> void`. The `callback` function is called when all handlers called the callback without `err`. If any handler calls the callback with `err`, `callback` is invoked with this error and the other handlers are ignored.

+

+### applyPluginsParallelBailResult

+

+``` javascript

+applyPluginsParallelBailResult(

+	name: string,

+	args: any...,

+	callback: (err: Error, result: any) -> void

+)

+```

+

+Applies all registered handlers for `name` parallel. The handler functions are called with all args and a callback function with the signature `(err?: Error) -> void`. Handler functions must call the callback. They can either pass an error, or pass undefined, or pass an value. The first result (either error or value) with is not undefined is passed to the `callback`. The order is defined by registeration not by speed of the handler function. This function compentate this.

diff --git a/node_modules/tapable/lib/Tapable.js b/node_modules/tapable/lib/Tapable.js
new file mode 100644
index 000000000..c7521baf7
--- /dev/null
+++ b/node_modules/tapable/lib/Tapable.js
@@ -0,0 +1,308 @@
+/*

+	MIT License http://www.opensource.org/licenses/mit-license.php

+	Author Tobias Koppers @sokra

+*/

+

+// polyfill from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

+// using the polyfill specifically to avoid the call to `Object.defineProperty` for performance reasons

+function fastFilter(fun/*, thisArg*/) {

+	'use strict';

+

+	if (this === void 0 || this === null) {

+		throw new TypeError();

+	}

+

+	var t = Object(this);

+	var len = t.length >>> 0;

+	if (typeof fun !== 'function') {

+		throw new TypeError();

+	}

+

+	var res = [];

+	var thisArg = arguments.length >= 2 ? arguments[1] : void 0;

+	for (var i = 0; i < len; i++) {

+		if (i in t) {

+			var val = t[i];

+

+			// NOTE: Technically this should Object.defineProperty at

+			//       the next index, as push can be affected by

+			//       properties on Object.prototype and Array.prototype.

+			//       But that method's new, and collisions should be

+			//       rare, so use the more-compatible alternative.

+			if (fun.call(thisArg, val, i, t)) {

+				res.push(val);

+			}

+		}

+	}

+

+	return res;

+}

+

+function Tapable() {

+	this._plugins = {};

+}

+module.exports = Tapable;

+

+function copyProperties(from, to) {

+	for(var key in from)

+		to[key] = from[key];

+	return to;

+}

+

+Tapable.mixin = function mixinTapable(pt) {

+	copyProperties(Tapable.prototype, pt);

+};

+

+Tapable.prototype.applyPlugins = function applyPlugins(name) {

+	if(!this._plugins[name]) return;

+	var args = Array.prototype.slice.call(arguments, 1);

+	var plugins = this._plugins[name];

+	for(var i = 0; i < plugins.length; i++)

+		plugins[i].apply(this, args);

+};

+

+Tapable.prototype.applyPlugins0 = function applyPlugins0(name) {

+	var plugins = this._plugins[name];

+	if(!plugins) return;

+	for(var i = 0; i < plugins.length; i++)

+		plugins[i].call(this);

+};

+

+Tapable.prototype.applyPlugins1 = function applyPlugins1(name, param) {

+	var plugins = this._plugins[name];

+	if(!plugins) return;

+	for(var i = 0; i < plugins.length; i++)

+		plugins[i].call(this, param);

+};

+

+Tapable.prototype.applyPlugins2 = function applyPlugins2(name, param1, param2) {

+	var plugins = this._plugins[name];

+	if(!plugins) return;

+	for(var i = 0; i < plugins.length; i++)

+		plugins[i].call(this, param1, param2);

+};

+

+Tapable.prototype.applyPluginsWaterfall = function applyPluginsWaterfall(name, init) {

+	if(!this._plugins[name]) return init;

+	var args = Array.prototype.slice.call(arguments, 2);

+	var plugins = this._plugins[name];

+	var current = init;

+	for(var i = 0; i < plugins.length; i++)

+		current = plugins[i].apply(this, [current].concat(args));

+	return current;

+};

+

+Tapable.prototype.applyPluginsWaterfall0 = function applyPluginsWaterfall0(name, init) {

+	var plugins = this._plugins[name];

+	if(!plugins) return init;

+	var current = init;

+	for(var i = 0; i < plugins.length; i++)

+		current = plugins[i].call(this, current);

+	return current;

+};

+

+Tapable.prototype.applyPluginsBailResult = function applyPluginsBailResult(name) {

+	if(!this._plugins[name]) return;

+	var args = Array.prototype.slice.call(arguments, 1);

+	var plugins = this._plugins[name];

+	for(var i = 0; i < plugins.length; i++) {

+		var result = plugins[i].apply(this, args);

+		if(typeof result !== "undefined") {

+			return result;

+		}

+	}

+};

+

+Tapable.prototype.applyPluginsBailResult1 = function applyPluginsBailResult1(name, param) {

+	if(!this._plugins[name]) return;

+	var plugins = this._plugins[name];

+	for(var i = 0; i < plugins.length; i++) {

+		var result = plugins[i].call(this, param);

+		if(typeof result !== "undefined") {

+			return result;

+		}

+	}

+};

+

+Tapable.prototype.applyPluginsAsyncSeries = Tapable.prototype.applyPluginsAsync = function applyPluginsAsyncSeries(name) {

+	var args = Array.prototype.slice.call(arguments, 1);

+	var callback = args.pop();

+	var plugins = this._plugins[name];

+	if(!plugins || plugins.length === 0) return callback();

+	var i = 0;

+	var _this = this;

+	args.push(copyProperties(callback, function next(err) {

+		if(err) return callback(err);

+		i++;

+		if(i >= plugins.length) {

+			return callback();

+		}

+		plugins[i].apply(_this, args);

+	}));

+	plugins[0].apply(this, args);

+};

+

+Tapable.prototype.applyPluginsAsyncSeries1 = function applyPluginsAsyncSeries1(name, param, callback) {

+	var plugins = this._plugins[name];

+	if(!plugins || plugins.length === 0) return callback();

+	var i = 0;

+	var _this = this;

+	var innerCallback = copyProperties(callback, function next(err) {

+		if(err) return callback(err);

+		i++;

+		if(i >= plugins.length) {

+			return callback();

+		}

+		plugins[i].call(_this, param, innerCallback);

+	});

+	plugins[0].call(this, param, innerCallback);

+};

+

+Tapable.prototype.applyPluginsAsyncSeriesBailResult = function applyPluginsAsyncSeriesBailResult(name) {

+	var args = Array.prototype.slice.call(arguments, 1);

+	var callback = args.pop();

+	if(!this._plugins[name] || this._plugins[name].length === 0) return callback();

+	var plugins = this._plugins[name];

+	var i = 0;

+	var _this = this;

+	args.push(copyProperties(callback, function next() {

+		if(arguments.length > 0) return callback.apply(null, arguments);

+		i++;

+		if(i >= plugins.length) {

+			return callback();

+		}

+		plugins[i].apply(_this, args);

+	}));

+	plugins[0].apply(this, args);

+};

+

+Tapable.prototype.applyPluginsAsyncSeriesBailResult1 = function applyPluginsAsyncSeriesBailResult1(name, param, callback) {

+	var plugins = this._plugins[name];

+	if(!plugins || plugins.length === 0) return callback();

+	var i = 0;

+	var _this = this;

+	var innerCallback = copyProperties(callback, function next(err, result) {

+		if(arguments.length > 0) return callback(err, result);

+		i++;

+		if(i >= plugins.length) {

+			return callback();

+		}

+		plugins[i].call(_this, param, innerCallback);

+	});

+	plugins[0].call(this, param, innerCallback);

+};

+

+Tapable.prototype.applyPluginsAsyncWaterfall = function applyPluginsAsyncWaterfall(name, init, callback) {

+	if(!this._plugins[name] || this._plugins[name].length === 0) return callback(null, init);

+	var plugins = this._plugins[name];

+	var i = 0;

+	var _this = this;

+	var next = copyProperties(callback, function(err, value) {

+		if(err) return callback(err);

+		i++;

+		if(i >= plugins.length) {

+			return callback(null, value);

+		}

+		plugins[i].call(_this, value, next);

+	});

+	plugins[0].call(this, init, next);

+};

+

+Tapable.prototype.applyPluginsParallel = function applyPluginsParallel(name) {

+	var args = Array.prototype.slice.call(arguments, 1);

+	var callback = args.pop();

+	if(!this._plugins[name] || this._plugins[name].length === 0) return callback();

+	var plugins = this._plugins[name];

+	var remaining = plugins.length;

+	args.push(copyProperties(callback, function(err) {

+		if(remaining < 0) return; // ignore

+		if(err) {

+			remaining = -1;

+			return callback(err);

+		}

+		remaining--;

+		if(remaining === 0) {

+			return callback();

+		}

+	}));

+	for(var i = 0; i < plugins.length; i++) {

+		plugins[i].apply(this, args);

+		if(remaining < 0) return;

+	}

+};

+

+Tapable.prototype.applyPluginsParallelBailResult = function applyPluginsParallelBailResult(name) {

+	var args = Array.prototype.slice.call(arguments, 1);

+	var callback = args[args.length - 1];

+	if(!this._plugins[name] || this._plugins[name].length === 0) return callback();

+	var plugins = this._plugins[name];

+	var currentPos = plugins.length;

+	var currentResult;

+	var done = [];

+	for(var i = 0; i < plugins.length; i++) {

+		args[args.length - 1] = (function(i) {

+			return copyProperties(callback, function() {

+				if(i >= currentPos) return; // ignore

+				done.push(i);

+				if(arguments.length > 0) {

+					currentPos = i + 1;

+					done = fastFilter.call(done, function(item) {

+						return item <= i;

+					});

+					currentResult = Array.prototype.slice.call(arguments);

+				}

+				if(done.length === currentPos) {

+					callback.apply(null, currentResult);

+					currentPos = 0;

+				}

+			});

+		}(i));

+		plugins[i].apply(this, args);

+	}

+};

+

+Tapable.prototype.applyPluginsParallelBailResult1 = function applyPluginsParallelBailResult1(name, param, callback) {

+	var plugins = this._plugins[name];

+	if(!plugins || plugins.length === 0) return callback();

+	var currentPos = plugins.length;

+	var currentResult;

+	var done = [];

+	for(var i = 0; i < plugins.length; i++) {

+		var innerCallback = (function(i) {

+			return copyProperties(callback, function() {

+				if(i >= currentPos) return; // ignore

+				done.push(i);

+				if(arguments.length > 0) {

+					currentPos = i + 1;

+					done = fastFilter.call(done, function(item) {

+						return item <= i;

+					});

+					currentResult = Array.prototype.slice.call(arguments);

+				}

+				if(done.length === currentPos) {

+					callback.apply(null, currentResult);

+					currentPos = 0;

+				}

+			});

+		}(i));

+		plugins[i].call(this, param, innerCallback);

+	}

+};

+

+

+Tapable.prototype.plugin = function plugin(name, fn) {

+	if(Array.isArray(name)) {

+		name.forEach(function(name) {

+			this.plugin(name, fn);

+		}, this);

+		return;

+	}

+	if(!this._plugins[name]) this._plugins[name] = [fn];

+	else this._plugins[name].push(fn);

+};

+

+Tapable.prototype.apply = function apply() {

+	for(var i = 0; i < arguments.length; i++) {

+		arguments[i].apply(this);

+	}

+};

diff --git a/node_modules/tapable/package.json b/node_modules/tapable/package.json
new file mode 100644
index 000000000..1d4941fd8
--- /dev/null
+++ b/node_modules/tapable/package.json
@@ -0,0 +1,26 @@
+{
+  "name": "tapable",
+  "version": "0.2.6",
+  "author": "Tobias Koppers @sokra",
+  "description": "Just a little module for plugins.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/webpack/tapable.git"
+  },
+  "devDependencies": {
+    "mocha": "^2.2.4",
+    "should": "^5.2.0"
+  },
+  "engines": {
+    "node": ">=0.6"
+  },
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/webpack/tapable",
+  "main": "lib/Tapable.js",
+  "scripts": {
+    "test": "mocha --reporter spec"
+  }
+}