api, login, auth

16 files changed, 1216 insertions, 0 deletions

diff --git a/node_modules/tapable/lib/AsyncParallelBailHook.js b/node_modules/tapable/lib/AsyncParallelBailHook.js
new file mode 100644
index 0000000..3f4476d
--- /dev/null
+++ b/node_modules/tapable/lib/AsyncParallelBailHook.js
@@ -0,0 +1,80 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class AsyncParallelBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, onDone }) {
+		let code = "";
+		code += `var _results = new Array(${this.options.taps.length});\n`;
+		code += "var _checkDone = () => {\n";
+		code += "for(var i = 0; i < _results.length; i++) {\n";
+		code += "var item = _results[i];\n";
+		code += "if(item === undefined) return false;\n";
+		code += "if(item.result !== undefined) {\n";
+		code += onResult("item.result");
+		code += "return true;\n";
+		code += "}\n";
+		code += "if(item.error) {\n";
+		code += onError("item.error");
+		code += "return true;\n";
+		code += "}\n";
+		code += "}\n";
+		code += "return false;\n";
+		code += "}\n";
+		code += this.callTapsParallel({
+			onError: (i, err, done, doneBreak) => {
+				let code = "";
+				code += `if(${i} < _results.length && ((_results.length = ${i +
+					1}), (_results[${i}] = { error: ${err} }), _checkDone())) {\n`;
+				code += doneBreak(true);
+				code += "} else {\n";
+				code += done();
+				code += "}\n";
+				return code;
+			},
+			onResult: (i, result, done, doneBreak) => {
+				let code = "";
+				code += `if(${i} < _results.length && (${result} !== undefined && (_results.length = ${i +
+					1}), (_results[${i}] = { result: ${result} }), _checkDone())) {\n`;
+				code += doneBreak(true);
+				code += "} else {\n";
+				code += done();
+				code += "}\n";
+				return code;
+			},
+			onTap: (i, run, done, doneBreak) => {
+				let code = "";
+				if (i > 0) {
+					code += `if(${i} >= _results.length) {\n`;
+					code += done();
+					code += "} else {\n";
+				}
+				code += run();
+				if (i > 0) code += "}\n";
+				return code;
+			},
+			onDone
+		});
+		return code;
+	}
+}
+
+const factory = new AsyncParallelBailHookCodeFactory();
+
+class AsyncParallelBailHook extends Hook {
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+Object.defineProperties(AsyncParallelBailHook.prototype, {
+	_call: { value: undefined, configurable: true, writable: true }
+});
+
+module.exports = AsyncParallelBailHook;
diff --git a/node_modules/tapable/lib/AsyncParallelHook.js b/node_modules/tapable/lib/AsyncParallelHook.js
new file mode 100644
index 0000000..d1e0237
--- /dev/null
+++ b/node_modules/tapable/lib/AsyncParallelHook.js
@@ -0,0 +1,32 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class AsyncParallelHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsParallel({
+			onError: (i, err, done, doneBreak) => onError(err) + doneBreak(true),
+			onDone
+		});
+	}
+}
+
+const factory = new AsyncParallelHookCodeFactory();
+
+class AsyncParallelHook extends Hook {
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+Object.defineProperties(AsyncParallelHook.prototype, {
+	_call: { value: undefined, configurable: true, writable: true }
+});
+
+module.exports = AsyncParallelHook;
diff --git a/node_modules/tapable/lib/AsyncSeriesBailHook.js b/node_modules/tapable/lib/AsyncSeriesBailHook.js
new file mode 100644
index 0000000..dc10935
--- /dev/null
+++ b/node_modules/tapable/lib/AsyncSeriesBailHook.js
@@ -0,0 +1,37 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class AsyncSeriesBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onResult: (i, result, next) =>
+				`if(${result} !== undefined) {\n${onResult(
+					result
+				)};\n} else {\n${next()}}\n`,
+			resultReturns,
+			onDone
+		});
+	}
+}
+
+const factory = new AsyncSeriesBailHookCodeFactory();
+
+class AsyncSeriesBailHook extends Hook {
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+Object.defineProperties(AsyncSeriesBailHook.prototype, {
+	_call: { value: undefined, configurable: true, writable: true }
+});
+
+module.exports = AsyncSeriesBailHook;
diff --git a/node_modules/tapable/lib/AsyncSeriesHook.js b/node_modules/tapable/lib/AsyncSeriesHook.js
new file mode 100644
index 0000000..f021c44
--- /dev/null
+++ b/node_modules/tapable/lib/AsyncSeriesHook.js
@@ -0,0 +1,32 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class AsyncSeriesHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onDone
+		});
+	}
+}
+
+const factory = new AsyncSeriesHookCodeFactory();
+
+class AsyncSeriesHook extends Hook {
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+Object.defineProperties(AsyncSeriesHook.prototype, {
+	_call: { value: undefined, configurable: true, writable: true }
+});
+
+module.exports = AsyncSeriesHook;
diff --git a/node_modules/tapable/lib/AsyncSeriesLoopHook.js b/node_modules/tapable/lib/AsyncSeriesLoopHook.js
new file mode 100644
index 0000000..f500288
--- /dev/null
+++ b/node_modules/tapable/lib/AsyncSeriesLoopHook.js
@@ -0,0 +1,32 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class AsyncSeriesLoopHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone }) {
+		return this.callTapsLooping({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onDone
+		});
+	}
+}
+
+const factory = new AsyncSeriesLoopHookCodeFactory();
+
+class AsyncSeriesLoopHook extends Hook {
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+Object.defineProperties(AsyncSeriesLoopHook.prototype, {
+	_call: { value: undefined, configurable: true, writable: true }
+});
+
+module.exports = AsyncSeriesLoopHook;
diff --git a/node_modules/tapable/lib/AsyncSeriesWaterfallHook.js b/node_modules/tapable/lib/AsyncSeriesWaterfallHook.js
new file mode 100644
index 0000000..d5532bf
--- /dev/null
+++ b/node_modules/tapable/lib/AsyncSeriesWaterfallHook.js
@@ -0,0 +1,46 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class AsyncSeriesWaterfallHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, onDone }) {
+		return this.callTapsSeries({
+			onError: (i, err, next, doneBreak) => onError(err) + doneBreak(true),
+			onResult: (i, result, next) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += `${this._args[0]} = ${result};\n`;
+				code += `}\n`;
+				code += next();
+				return code;
+			},
+			onDone: () => onResult(this._args[0])
+		});
+	}
+}
+
+const factory = new AsyncSeriesWaterfallHookCodeFactory();
+
+class AsyncSeriesWaterfallHook extends Hook {
+	constructor(args) {
+		super(args);
+		if (args.length < 1)
+			throw new Error("Waterfall hooks must have at least one argument");
+	}
+
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+Object.defineProperties(AsyncSeriesWaterfallHook.prototype, {
+	_call: { value: undefined, configurable: true, writable: true }
+});
+
+module.exports = AsyncSeriesWaterfallHook;
diff --git a/node_modules/tapable/lib/Hook.js b/node_modules/tapable/lib/Hook.js
new file mode 100644
index 0000000..6a976e9
--- /dev/null
+++ b/node_modules/tapable/lib/Hook.js
@@ -0,0 +1,176 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class Hook {
+	constructor(args) {
+		if (!Array.isArray(args)) args = [];
+		this._args = args;
+		this.taps = [];
+		this.interceptors = [];
+		this.call = this._call;
+		this.promise = this._promise;
+		this.callAsync = this._callAsync;
+		this._x = undefined;
+	}
+
+	compile(options) {
+		throw new Error("Abstract: should be overriden");
+	}
+
+	_createCall(type) {
+		return this.compile({
+			taps: this.taps,
+			interceptors: this.interceptors,
+			args: this._args,
+			type: type
+		});
+	}
+
+	tap(options, fn) {
+		if (typeof options === "string") options = { name: options };
+		if (typeof options !== "object" || options === null)
+			throw new Error(
+				"Invalid arguments to tap(options: Object, fn: function)"
+			);
+		options = Object.assign({ type: "sync", fn: fn }, options);
+		if (typeof options.name !== "string" || options.name === "")
+			throw new Error("Missing name for tap");
+		options = this._runRegisterInterceptors(options);
+		this._insert(options);
+	}
+
+	tapAsync(options, fn) {
+		if (typeof options === "string") options = { name: options };
+		if (typeof options !== "object" || options === null)
+			throw new Error(
+				"Invalid arguments to tapAsync(options: Object, fn: function)"
+			);
+		options = Object.assign({ type: "async", fn: fn }, options);
+		if (typeof options.name !== "string" || options.name === "")
+			throw new Error("Missing name for tapAsync");
+		options = this._runRegisterInterceptors(options);
+		this._insert(options);
+	}
+
+	tapPromise(options, fn) {
+		if (typeof options === "string") options = { name: options };
+		if (typeof options !== "object" || options === null)
+			throw new Error(
+				"Invalid arguments to tapPromise(options: Object, fn: function)"
+			);
+		options = Object.assign({ type: "promise", fn: fn }, options);
+		if (typeof options.name !== "string" || options.name === "")
+			throw new Error("Missing name for tapPromise");
+		options = this._runRegisterInterceptors(options);
+		this._insert(options);
+	}
+
+	_runRegisterInterceptors(options) {
+		for (const interceptor of this.interceptors) {
+			if (interceptor.register) {
+				const newOptions = interceptor.register(options);
+				if (newOptions !== undefined) options = newOptions;
+			}
+		}
+		return options;
+	}
+
+	withOptions(options) {
+		const mergeOptions = opt =>
+			Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);
+
+		// Prevent creating endless prototype chains
+		options = Object.assign({}, options, this._withOptions);
+		const base = this._withOptionsBase || this;
+		const newHook = Object.create(base);
+
+		(newHook.tapAsync = (opt, fn) => base.tapAsync(mergeOptions(opt), fn)),
+			(newHook.tap = (opt, fn) => base.tap(mergeOptions(opt), fn));
+		newHook.tapPromise = (opt, fn) => base.tapPromise(mergeOptions(opt), fn);
+		newHook._withOptions = options;
+		newHook._withOptionsBase = base;
+		return newHook;
+	}
+
+	isUsed() {
+		return this.taps.length > 0 || this.interceptors.length > 0;
+	}
+
+	intercept(interceptor) {
+		this._resetCompilation();
+		this.interceptors.push(Object.assign({}, interceptor));
+		if (interceptor.register) {
+			for (let i = 0; i < this.taps.length; i++)
+				this.taps[i] = interceptor.register(this.taps[i]);
+		}
+	}
+
+	_resetCompilation() {
+		this.call = this._call;
+		this.callAsync = this._callAsync;
+		this.promise = this._promise;
+	}
+
+	_insert(item) {
+		this._resetCompilation();
+		let before;
+		if (typeof item.before === "string") before = new Set([item.before]);
+		else if (Array.isArray(item.before)) {
+			before = new Set(item.before);
+		}
+		let stage = 0;
+		if (typeof item.stage === "number") stage = item.stage;
+		let i = this.taps.length;
+		while (i > 0) {
+			i--;
+			const x = this.taps[i];
+			this.taps[i + 1] = x;
+			const xStage = x.stage || 0;
+			if (before) {
+				if (before.has(x.name)) {
+					before.delete(x.name);
+					continue;
+				}
+				if (before.size > 0) {
+					continue;
+				}
+			}
+			if (xStage > stage) {
+				continue;
+			}
+			i++;
+			break;
+		}
+		this.taps[i] = item;
+	}
+}
+
+function createCompileDelegate(name, type) {
+	return function lazyCompileHook(...args) {
+		this[name] = this._createCall(type);
+		return this[name](...args);
+	};
+}
+
+Object.defineProperties(Hook.prototype, {
+	_call: {
+		value: createCompileDelegate("call", "sync"),
+		configurable: true,
+		writable: true
+	},
+	_promise: {
+		value: createCompileDelegate("promise", "promise"),
+		configurable: true,
+		writable: true
+	},
+	_callAsync: {
+		value: createCompileDelegate("callAsync", "async"),
+		configurable: true,
+		writable: true
+	}
+});
+
+module.exports = Hook;
diff --git a/node_modules/tapable/lib/HookCodeFactory.js b/node_modules/tapable/lib/HookCodeFactory.js
new file mode 100644
index 0000000..36ff2bd
--- /dev/null
+++ b/node_modules/tapable/lib/HookCodeFactory.js
@@ -0,0 +1,407 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class HookCodeFactory {
+	constructor(config) {
+		this.config = config;
+		this.options = undefined;
+		this._args = undefined;
+	}
+
+	create(options) {
+		this.init(options);
+		let fn;
+		switch (this.options.type) {
+			case "sync":
+				fn = new Function(
+					this.args(),
+					'"use strict";\n' +
+						this.header() +
+						this.content({
+							onError: err => `throw ${err};\n`,
+							onResult: result => `return ${result};\n`,
+							resultReturns: true,
+							onDone: () => "",
+							rethrowIfPossible: true
+						})
+				);
+				break;
+			case "async":
+				fn = new Function(
+					this.args({
+						after: "_callback"
+					}),
+					'"use strict";\n' +
+						this.header() +
+						this.content({
+							onError: err => `_callback(${err});\n`,
+							onResult: result => `_callback(null, ${result});\n`,
+							onDone: () => "_callback();\n"
+						})
+				);
+				break;
+			case "promise":
+				let errorHelperUsed = false;
+				const content = this.content({
+					onError: err => {
+						errorHelperUsed = true;
+						return `_error(${err});\n`;
+					},
+					onResult: result => `_resolve(${result});\n`,
+					onDone: () => "_resolve();\n"
+				});
+				let code = "";
+				code += '"use strict";\n';
+				code += "return new Promise((_resolve, _reject) => {\n";
+				if (errorHelperUsed) {
+					code += "var _sync = true;\n";
+					code += "function _error(_err) {\n";
+					code += "if(_sync)\n";
+					code += "_resolve(Promise.resolve().then(() => { throw _err; }));\n";
+					code += "else\n";
+					code += "_reject(_err);\n";
+					code += "};\n";
+				}
+				code += this.header();
+				code += content;
+				if (errorHelperUsed) {
+					code += "_sync = false;\n";
+				}
+				code += "});\n";
+				fn = new Function(this.args(), code);
+				break;
+		}
+		this.deinit();
+		return fn;
+	}
+
+	setup(instance, options) {
+		instance._x = options.taps.map(t => t.fn);
+	}
+
+	/**
+	 * @param {{ type: "sync" | "promise" | "async", taps: Array<Tap>, interceptors: Array<Interceptor> }} options
+	 */
+	init(options) {
+		this.options = options;
+		this._args = options.args.slice();
+	}
+
+	deinit() {
+		this.options = undefined;
+		this._args = undefined;
+	}
+
+	header() {
+		let code = "";
+		if (this.needContext()) {
+			code += "var _context = {};\n";
+		} else {
+			code += "var _context;\n";
+		}
+		code += "var _x = this._x;\n";
+		if (this.options.interceptors.length > 0) {
+			code += "var _taps = this.taps;\n";
+			code += "var _interceptors = this.interceptors;\n";
+		}
+		for (let i = 0; i < this.options.interceptors.length; i++) {
+			const interceptor = this.options.interceptors[i];
+			if (interceptor.call) {
+				code += `${this.getInterceptor(i)}.call(${this.args({
+					before: interceptor.context ? "_context" : undefined
+				})});\n`;
+			}
+		}
+		return code;
+	}
+
+	needContext() {
+		for (const tap of this.options.taps) if (tap.context) return true;
+		return false;
+	}
+
+	callTap(tapIndex, { onError, onResult, onDone, rethrowIfPossible }) {
+		let code = "";
+		let hasTapCached = false;
+		for (let i = 0; i < this.options.interceptors.length; i++) {
+			const interceptor = this.options.interceptors[i];
+			if (interceptor.tap) {
+				if (!hasTapCached) {
+					code += `var _tap${tapIndex} = ${this.getTap(tapIndex)};\n`;
+					hasTapCached = true;
+				}
+				code += `${this.getInterceptor(i)}.tap(${
+					interceptor.context ? "_context, " : ""
+				}_tap${tapIndex});\n`;
+			}
+		}
+		code += `var _fn${tapIndex} = ${this.getTapFn(tapIndex)};\n`;
+		const tap = this.options.taps[tapIndex];
+		switch (tap.type) {
+			case "sync":
+				if (!rethrowIfPossible) {
+					code += `var _hasError${tapIndex} = false;\n`;
+					code += "try {\n";
+				}
+				if (onResult) {
+					code += `var _result${tapIndex} = _fn${tapIndex}(${this.args({
+						before: tap.context ? "_context" : undefined
+					})});\n`;
+				} else {
+					code += `_fn${tapIndex}(${this.args({
+						before: tap.context ? "_context" : undefined
+					})});\n`;
+				}
+				if (!rethrowIfPossible) {
+					code += "} catch(_err) {\n";
+					code += `_hasError${tapIndex} = true;\n`;
+					code += onError("_err");
+					code += "}\n";
+					code += `if(!_hasError${tapIndex}) {\n`;
+				}
+				if (onResult) {
+					code += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					code += onDone();
+				}
+				if (!rethrowIfPossible) {
+					code += "}\n";
+				}
+				break;
+			case "async":
+				let cbCode = "";
+				if (onResult) cbCode += `(_err${tapIndex}, _result${tapIndex}) => {\n`;
+				else cbCode += `_err${tapIndex} => {\n`;
+				cbCode += `if(_err${tapIndex}) {\n`;
+				cbCode += onError(`_err${tapIndex}`);
+				cbCode += "} else {\n";
+				if (onResult) {
+					cbCode += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					cbCode += onDone();
+				}
+				cbCode += "}\n";
+				cbCode += "}";
+				code += `_fn${tapIndex}(${this.args({
+					before: tap.context ? "_context" : undefined,
+					after: cbCode
+				})});\n`;
+				break;
+			case "promise":
+				code += `var _hasResult${tapIndex} = false;\n`;
+				code += `var _promise${tapIndex} = _fn${tapIndex}(${this.args({
+					before: tap.context ? "_context" : undefined
+				})});\n`;
+				code += `if (!_promise${tapIndex} || !_promise${tapIndex}.then)\n`;
+				code += `  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${tapIndex} + ')');\n`;
+				code += `_promise${tapIndex}.then(_result${tapIndex} => {\n`;
+				code += `_hasResult${tapIndex} = true;\n`;
+				if (onResult) {
+					code += onResult(`_result${tapIndex}`);
+				}
+				if (onDone) {
+					code += onDone();
+				}
+				code += `}, _err${tapIndex} => {\n`;
+				code += `if(_hasResult${tapIndex}) throw _err${tapIndex};\n`;
+				code += onError(`_err${tapIndex}`);
+				code += "});\n";
+				break;
+		}
+		return code;
+	}
+
+	callTapsSeries({
+		onError,
+		onResult,
+		resultReturns,
+		onDone,
+		doneReturns,
+		rethrowIfPossible
+	}) {
+		if (this.options.taps.length === 0) return onDone();
+		const firstAsync = this.options.taps.findIndex(t => t.type !== "sync");
+		const somethingReturns = resultReturns || doneReturns || false;
+		let code = "";
+		let current = onDone;
+		for (let j = this.options.taps.length - 1; j >= 0; j--) {
+			const i = j;
+			const unroll = current !== onDone && this.options.taps[i].type !== "sync";
+			if (unroll) {
+				code += `function _next${i}() {\n`;
+				code += current();
+				code += `}\n`;
+				current = () => `${somethingReturns ? "return " : ""}_next${i}();\n`;
+			}
+			const done = current;
+			const doneBreak = skipDone => {
+				if (skipDone) return "";
+				return onDone();
+			};
+			const content = this.callTap(i, {
+				onError: error => onError(i, error, done, doneBreak),
+				onResult:
+					onResult &&
+					(result => {
+						return onResult(i, result, done, doneBreak);
+					}),
+				onDone: !onResult && done,
+				rethrowIfPossible:
+					rethrowIfPossible && (firstAsync < 0 || i < firstAsync)
+			});
+			current = () => content;
+		}
+		code += current();
+		return code;
+	}
+
+	callTapsLooping({ onError, onDone, rethrowIfPossible }) {
+		if (this.options.taps.length === 0) return onDone();
+		const syncOnly = this.options.taps.every(t => t.type === "sync");
+		let code = "";
+		if (!syncOnly) {
+			code += "var _looper = () => {\n";
+			code += "var _loopAsync = false;\n";
+		}
+		code += "var _loop;\n";
+		code += "do {\n";
+		code += "_loop = false;\n";
+		for (let i = 0; i < this.options.interceptors.length; i++) {
+			const interceptor = this.options.interceptors[i];
+			if (interceptor.loop) {
+				code += `${this.getInterceptor(i)}.loop(${this.args({
+					before: interceptor.context ? "_context" : undefined
+				})});\n`;
+			}
+		}
+		code += this.callTapsSeries({
+			onError,
+			onResult: (i, result, next, doneBreak) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += "_loop = true;\n";
+				if (!syncOnly) code += "if(_loopAsync) _looper();\n";
+				code += doneBreak(true);
+				code += `} else {\n`;
+				code += next();
+				code += `}\n`;
+				return code;
+			},
+			onDone:
+				onDone &&
+				(() => {
+					let code = "";
+					code += "if(!_loop) {\n";
+					code += onDone();
+					code += "}\n";
+					return code;
+				}),
+			rethrowIfPossible: rethrowIfPossible && syncOnly
+		});
+		code += "} while(_loop);\n";
+		if (!syncOnly) {
+			code += "_loopAsync = true;\n";
+			code += "};\n";
+			code += "_looper();\n";
+		}
+		return code;
+	}
+
+	callTapsParallel({
+		onError,
+		onResult,
+		onDone,
+		rethrowIfPossible,
+		onTap = (i, run) => run()
+	}) {
+		if (this.options.taps.length <= 1) {
+			return this.callTapsSeries({
+				onError,
+				onResult,
+				onDone,
+				rethrowIfPossible
+			});
+		}
+		let code = "";
+		code += "do {\n";
+		code += `var _counter = ${this.options.taps.length};\n`;
+		if (onDone) {
+			code += "var _done = () => {\n";
+			code += onDone();
+			code += "};\n";
+		}
+		for (let i = 0; i < this.options.taps.length; i++) {
+			const done = () => {
+				if (onDone) return "if(--_counter === 0) _done();\n";
+				else return "--_counter;";
+			};
+			const doneBreak = skipDone => {
+				if (skipDone || !onDone) return "_counter = 0;\n";
+				else return "_counter = 0;\n_done();\n";
+			};
+			code += "if(_counter <= 0) break;\n";
+			code += onTap(
+				i,
+				() =>
+					this.callTap(i, {
+						onError: error => {
+							let code = "";
+							code += "if(_counter > 0) {\n";
+							code += onError(i, error, done, doneBreak);
+							code += "}\n";
+							return code;
+						},
+						onResult:
+							onResult &&
+							(result => {
+								let code = "";
+								code += "if(_counter > 0) {\n";
+								code += onResult(i, result, done, doneBreak);
+								code += "}\n";
+								return code;
+							}),
+						onDone:
+							!onResult &&
+							(() => {
+								return done();
+							}),
+						rethrowIfPossible
+					}),
+				done,
+				doneBreak
+			);
+		}
+		code += "} while(false);\n";
+		return code;
+	}
+
+	args({ before, after } = {}) {
+		let allArgs = this._args;
+		if (before) allArgs = [before].concat(allArgs);
+		if (after) allArgs = allArgs.concat(after);
+		if (allArgs.length === 0) {
+			return "";
+		} else {
+			return allArgs.join(", ");
+		}
+	}
+
+	getTapFn(idx) {
+		return `_x[${idx}]`;
+	}
+
+	getTap(idx) {
+		return `_taps[${idx}]`;
+	}
+
+	getInterceptor(idx) {
+		return `_interceptors[${idx}]`;
+	}
+}
+
+module.exports = HookCodeFactory;
diff --git a/node_modules/tapable/lib/HookMap.js b/node_modules/tapable/lib/HookMap.js
new file mode 100644
index 0000000..0397d8e
--- /dev/null
+++ b/node_modules/tapable/lib/HookMap.js
@@ -0,0 +1,56 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+class HookMap {
+	constructor(factory) {
+		this._map = new Map();
+		this._factory = factory;
+		this._interceptors = [];
+	}
+
+	get(key) {
+		return this._map.get(key);
+	}
+
+	for(key) {
+		const hook = this.get(key);
+		if (hook !== undefined) {
+			return hook;
+		}
+		let newHook = this._factory(key);
+		const interceptors = this._interceptors;
+		for (let i = 0; i < interceptors.length; i++) {
+			newHook = interceptors[i].factory(key, newHook);
+		}
+		this._map.set(key, newHook);
+		return newHook;
+	}
+
+	intercept(interceptor) {
+		this._interceptors.push(
+			Object.assign(
+				{
+					factory: (key, hook) => hook
+				},
+				interceptor
+			)
+		);
+	}
+
+	tap(key, options, fn) {
+		return this.for(key).tap(options, fn);
+	}
+
+	tapAsync(key, options, fn) {
+		return this.for(key).tapAsync(options, fn);
+	}
+
+	tapPromise(key, options, fn) {
+		return this.for(key).tapPromise(options, fn);
+	}
+}
+
+module.exports = HookMap;
diff --git a/node_modules/tapable/lib/MultiHook.js b/node_modules/tapable/lib/MultiHook.js
new file mode 100644
index 0000000..cddd917
--- /dev/null
+++ b/node_modules/tapable/lib/MultiHook.js
@@ -0,0 +1,50 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+
+class MultiHook {
+	constructor(hooks) {
+		this.hooks = hooks;
+	}
+
+	tap(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tap(options, fn);
+		}
+	}
+
+	tapAsync(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tapAsync(options, fn);
+		}
+	}
+
+	tapPromise(options, fn) {
+		for (const hook of this.hooks) {
+			hook.tapPromise(options, fn);
+		}
+	}
+
+	isUsed() {
+		for (const hook of this.hooks) {
+			if (hook.isUsed()) return true;
+		}
+		return false;
+	}
+
+	intercept(interceptor) {
+		for (const hook of this.hooks) {
+			hook.intercept(interceptor);
+		}
+	}
+
+	withOptions(options) {
+		return new MultiHook(this.hooks.map(h => h.withOptions(options)));
+	}
+}
+
+module.exports = MultiHook;
diff --git a/node_modules/tapable/lib/SyncBailHook.js b/node_modules/tapable/lib/SyncBailHook.js
new file mode 100644
index 0000000..f41e13e
--- /dev/null
+++ b/node_modules/tapable/lib/SyncBailHook.js
@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class SyncBailHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, onDone, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onResult: (i, result, next) =>
+				`if(${result} !== undefined) {\n${onResult(
+					result
+				)};\n} else {\n${next()}}\n`,
+			resultReturns,
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
+
+const factory = new SyncBailHookCodeFactory();
+
+class SyncBailHook extends Hook {
+	tapAsync() {
+		throw new Error("tapAsync is not supported on a SyncBailHook");
+	}
+
+	tapPromise() {
+		throw new Error("tapPromise is not supported on a SyncBailHook");
+	}
+
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+module.exports = SyncBailHook;
diff --git a/node_modules/tapable/lib/SyncHook.js b/node_modules/tapable/lib/SyncHook.js
new file mode 100644
index 0000000..7aa08bf
--- /dev/null
+++ b/node_modules/tapable/lib/SyncHook.js
@@ -0,0 +1,37 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class SyncHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
+
+const factory = new SyncHookCodeFactory();
+
+class SyncHook extends Hook {
+	tapAsync() {
+		throw new Error("tapAsync is not supported on a SyncHook");
+	}
+
+	tapPromise() {
+		throw new Error("tapPromise is not supported on a SyncHook");
+	}
+
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+module.exports = SyncHook;
diff --git a/node_modules/tapable/lib/SyncLoopHook.js b/node_modules/tapable/lib/SyncLoopHook.js
new file mode 100644
index 0000000..0986303
--- /dev/null
+++ b/node_modules/tapable/lib/SyncLoopHook.js
@@ -0,0 +1,37 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class SyncLoopHookCodeFactory extends HookCodeFactory {
+	content({ onError, onDone, rethrowIfPossible }) {
+		return this.callTapsLooping({
+			onError: (i, err) => onError(err),
+			onDone,
+			rethrowIfPossible
+		});
+	}
+}
+
+const factory = new SyncLoopHookCodeFactory();
+
+class SyncLoopHook extends Hook {
+	tapAsync() {
+		throw new Error("tapAsync is not supported on a SyncLoopHook");
+	}
+
+	tapPromise() {
+		throw new Error("tapPromise is not supported on a SyncLoopHook");
+	}
+
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+module.exports = SyncLoopHook;
diff --git a/node_modules/tapable/lib/SyncWaterfallHook.js b/node_modules/tapable/lib/SyncWaterfallHook.js
new file mode 100644
index 0000000..3996999
--- /dev/null
+++ b/node_modules/tapable/lib/SyncWaterfallHook.js
@@ -0,0 +1,52 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Hook = require("./Hook");
+const HookCodeFactory = require("./HookCodeFactory");
+
+class SyncWaterfallHookCodeFactory extends HookCodeFactory {
+	content({ onError, onResult, resultReturns, rethrowIfPossible }) {
+		return this.callTapsSeries({
+			onError: (i, err) => onError(err),
+			onResult: (i, result, next) => {
+				let code = "";
+				code += `if(${result} !== undefined) {\n`;
+				code += `${this._args[0]} = ${result};\n`;
+				code += `}\n`;
+				code += next();
+				return code;
+			},
+			onDone: () => onResult(this._args[0]),
+			doneReturns: resultReturns,
+			rethrowIfPossible
+		});
+	}
+}
+
+const factory = new SyncWaterfallHookCodeFactory();
+
+class SyncWaterfallHook extends Hook {
+	constructor(args) {
+		super(args);
+		if (args.length < 1)
+			throw new Error("Waterfall hooks must have at least one argument");
+	}
+
+	tapAsync() {
+		throw new Error("tapAsync is not supported on a SyncWaterfallHook");
+	}
+
+	tapPromise() {
+		throw new Error("tapPromise is not supported on a SyncWaterfallHook");
+	}
+
+	compile(options) {
+		factory.setup(this, options);
+		return factory.create(options);
+	}
+}
+
+module.exports = SyncWaterfallHook;
diff --git a/node_modules/tapable/lib/Tapable.js b/node_modules/tapable/lib/Tapable.js
new file mode 100644
index 0000000..530fea3
--- /dev/null
+++ b/node_modules/tapable/lib/Tapable.js
@@ -0,0 +1,81 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const util = require("util");
+const SyncBailHook = require("./SyncBailHook");
+
+function Tapable() {
+	this._pluginCompat = new SyncBailHook(["options"]);
+	this._pluginCompat.tap(
+		{
+			name: "Tapable camelCase",
+			stage: 100
+		},
+		options => {
+			options.names.add(
+				options.name.replace(/[- ]([a-z])/g, (str, ch) => ch.toUpperCase())
+			);
+		}
+	);
+	this._pluginCompat.tap(
+		{
+			name: "Tapable this.hooks",
+			stage: 200
+		},
+		options => {
+			let hook;
+			for (const name of options.names) {
+				hook = this.hooks[name];
+				if (hook !== undefined) {
+					break;
+				}
+			}
+			if (hook !== undefined) {
+				const tapOpt = {
+					name: options.fn.name || "unnamed compat plugin",
+					stage: options.stage || 0
+				};
+				if (options.async) hook.tapAsync(tapOpt, options.fn);
+				else hook.tap(tapOpt, options.fn);
+				return true;
+			}
+		}
+	);
+}
+module.exports = Tapable;
+
+Tapable.addCompatLayer = function addCompatLayer(instance) {
+	Tapable.call(instance);
+	instance.plugin = Tapable.prototype.plugin;
+	instance.apply = Tapable.prototype.apply;
+};
+
+Tapable.prototype.plugin = util.deprecate(function plugin(name, fn) {
+	if (Array.isArray(name)) {
+		name.forEach(function(name) {
+			this.plugin(name, fn);
+		}, this);
+		return;
+	}
+	const result = this._pluginCompat.call({
+		name: name,
+		fn: fn,
+		names: new Set([name])
+	});
+	if (!result) {
+		throw new Error(
+			`Plugin could not be registered at '${name}'. Hook was not found.\n` +
+				"BREAKING CHANGE: There need to exist a hook at 'this.hooks'. " +
+				"To create a compatibility layer for this hook, hook into 'this._pluginCompat'."
+		);
+	}
+}, "Tapable.plugin is deprecated. Use new API on `.hooks` instead");
+
+Tapable.prototype.apply = util.deprecate(function apply() {
+	for (var i = 0; i < arguments.length; i++) {
+		arguments[i].apply(this);
+	}
+}, "Tapable.apply is deprecated. Call apply on the plugin directly instead");
diff --git a/node_modules/tapable/lib/index.js b/node_modules/tapable/lib/index.js
new file mode 100644
index 0000000..2f5acad
--- /dev/null
+++ b/node_modules/tapable/lib/index.js
@@ -0,0 +1,19 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+exports.__esModule = true;
+exports.Tapable = require("./Tapable");
+exports.SyncHook = require("./SyncHook");
+exports.SyncBailHook = require("./SyncBailHook");
+exports.SyncWaterfallHook = require("./SyncWaterfallHook");
+exports.SyncLoopHook = require("./SyncLoopHook");
+exports.AsyncParallelHook = require("./AsyncParallelHook");
+exports.AsyncParallelBailHook = require("./AsyncParallelBailHook");
+exports.AsyncSeriesHook = require("./AsyncSeriesHook");
+exports.AsyncSeriesBailHook = require("./AsyncSeriesBailHook");
+exports.AsyncSeriesWaterfallHook = require("./AsyncSeriesWaterfallHook");
+exports.HookMap = require("./HookMap");
+exports.MultiHook = require("./MultiHook");