3 files changed, 0 insertions, 407 deletions
diff --git a/node_modules/tapable/README.md b/node_modules/tapable/README.md
deleted file mode 100644
index c68e7d09d..000000000
--- a/node_modules/tapable/README.md
+++ /dev/null
@@ -1,288 +0,0 @@
-# Tapable
-
-The tapable packages exposes many Hook classes, which can be used to create hooks for plugins.
-
-``` javascript
-const {
-	SyncHook,
-	SyncBailHook,
-	SyncWaterfallHook,
-	SyncLoopHook,
-	AsyncParallelHook,
-	AsyncParallelBailHook,
-	AsyncSeriesHook,
-	AsyncSeriesBailHook,
-	AsyncSeriesWaterfallHook
- } = require("tapable");
-```
-
-## Usage
-
-All Hook constructors take one optional argument, which is a list of argument names as strings.
-
-``` js
-const hook = new SyncHook(["arg1", "arg2", "arg3"]);
-```
-
-The best practice is to expose all hooks of a class in a `hooks` property:
-
-``` js
-class Car {
-	constructor() {
-		this.hooks = {
-			accelerate: new SyncHook(["newSpeed"]),
-			break: new SyncHook(),
-			calculateRoutes: new AsyncParallelHook(["source", "target", "routesList"])
-		};
-	}
-
-	/* ... */
-}
-```
-
-Other people can now use these hooks:
-
-``` js
-const myCar = new Car();
-
-// Use the tap method to add a consument
-myCar.hooks.break.tap("WarningLampPlugin", () => warningLamp.on());
-```
-
-It's required to pass a name to identify the plugin/reason.
-
-You may receive arguments:
-
-``` js
-myCar.hooks.accelerate.tap("LoggerPlugin", newSpeed => console.log(`Accelerating to ${newSpeed}`));
-```
-
-For sync hooks `tap` is the only valid method to add a plugin. Async hooks also support async plugins:
-
-``` js
-myCar.hooks.calculateRoutes.tapPromise("GoogleMapsPlugin", (source, target, routesList) => {
-	// return a promise
-	return google.maps.findRoute(source, target).then(route => {
-		routesList.add(route);
-	});
-});
-myCar.hooks.calculateRoutes.tapAsync("BingMapsPlugin", (source, target, routesList, callback) => {
-	bing.findRoute(source, target, (err, route) => {
-		if(err) return callback(err);
-		routesList.add(route);
-		// call the callback
-		callback();
-	});
-});
-
-// You can still use sync plugins
-myCar.hooks.calculateRoutes.tap("CachedRoutesPlugin", (source, target, routesList) => {
-	const cachedRoute = cache.get(source, target);
-	if(cachedRoute)
-		routesList.add(cachedRoute);
-})
-```
-
-The class declaring these hooks need to call them:
-
-``` js
-class Car {
-	/* ... */
-
-	setSpeed(newSpeed) {
-		this.hooks.accelerate.call(newSpeed);
-	}
-
-	useNavigationSystemPromise(source, target) {
-		const routesList = new List();
-		return this.hooks.calculateRoutes.promise(source, target, routesList).then(() => {
-			return routesList.getRoutes();
-		});
-	}
-
-	useNavigationSystemAsync(source, target, callback) {
-		const routesList = new List();
-		this.hooks.calculateRoutes.callAsync(source, target, routesList, err => {
-			if(err) return callback(err);
-			callback(null, routesList.getRoutes());
-		});
-	}
-}
-```
-
-The Hook will compile a method with the most efficient way of running your plugins. It generates code depending on:
-* The number of registered plugins (none, one, many)
-* The kind of registered plugins (sync, async, promise)
-* The used call method (sync, async, promise)
-* The number of arguments
-* Whether interception is used
-
-This ensures fastest possible execution.
-
-## Hook types
-
-Each hook can be tapped with one or several functions. How they are executed depends on the hook type:
-
-* Basic hook (without “Waterfall”, “Bail” or “Loop” in its name). This hook simply calls every function it’s tapped with in a row.
-
-* __Waterfall__. A waterfall hook also calls each tapped function in a row. Unlike the basic hook, it passes a return value from each function to the next function.
-
-* __Bail__. A bail hook allows exitting early. When any of the tapped function returns anything, the bail hook will stop executing the remaining ones.
-
-* __Loop__. TODO
-
-Additionally, hooks can be synchronous or asynchronous. To reflect this, there’re “Sync”, “AsyncSeries” and “AsyncParallel” hook classes:
-
-* __Sync__. A sync hooks can only be tapped with synchronous functions (using `myHook.tap()`).
-
-* __AsyncSeries__. Async-series hooks can be tapped with synchronous, callback-based and promise-based functions (using `myHook.tap()`, `myHook.tapAsync()` and `myHook.tapPromise()`). They call each async method in a row.
-
-* __AsyncParallel__. Async-parallel hooks can also be tapped with synchronous, callback-based and promise-based functions (using `myHook.tap()`, `myHook.tapAsync()` and `myHook.tapPromise()`). However, they run each async method in parallel.
-
-The hook type is reflected in its class name. E.g., `AsyncSeriesWaterfallHook` allows asynchronous functions and runs them in series passing each function’s return value into the next function.
-
-
-## Interception
-
-All Hooks offer an additional interception API:
-
-``` js
-myCar.hooks.calculateRoutes.intercept({
-	call: (source, target, routesList) => {
-		console.log("Starting to calculate routes");
-	},
-	register: (tapInfo) => {
-		// tapInfo = { type: "promise", name: "GoogleMapsPlugin", fn: ... }
-		console.log(`${tapInfo.name} is doing it's job`);
-		return tapInfo; // may return a new tapInfo object
-	}
-})
-```
-
-**call**: `(...args) => void` Adding `call` to your interceptor will trigger when hooks are triggered. You have access to the hooks arguments.
-
-**tap**: `(tap: Tap) => void` Adding `tap` to your interceptor will trigger when a plugin taps into a hook. Provided is the `Tap` object. `Tap` object can't be changed.
-
-**loop**: `(...args) => void` Adding `loop` to your interceptor will trigger for each loop of a looping hook.
-
-**register**: `(tap: Tap) => Tap | undefined` Adding `register` to your interceptor will trigger for each added `Tap` and allows to modify it.
-
-## Context
-
-Plugins and interceptors can opt-in to access an optional `context` object, which can be used to pass arbitrary values to subsequent plugins and interceptors.
-
-``` js
-myCar.hooks.accelerate.intercept({
-	context: true,
-	tap: (context, tapInfo) => {
-		// tapInfo = { type: "sync", name: "NoisePlugin", fn: ... }
-		console.log(`${tapInfo.name} is doing it's job`);
-
-		// `context` starts as an empty object if at least one plugin uses `context: true`.
-		// If no plugins use `context: true`, then `context` is undefined.
-		if (context) {
-			// Arbitrary properties can be added to `context`, which plugins can then access.
-			context.hasMuffler = true;
-		}
-	}
-});
-
-myCar.hooks.accelerate.tap({
-	name: "NoisePlugin",
-	context: true
-}, (context, newSpeed) => {
-	if (context && context.hasMuffler) {
-		console.log("Silence...");
-	} else {
-		console.log("Vroom!");
-	}
-});
-```
-
-## HookMap
-
-A HookMap is a helper class for a Map with Hooks
-
-``` js
-const keyedHook = new HookMap(key => new SyncHook(["arg"]))
-```
-
-``` js
-keyedHook.tap("some-key", "MyPlugin", (arg) => { /* ... */ });
-keyedHook.tapAsync("some-key", "MyPlugin", (arg, callback) => { /* ... */ });
-keyedHook.tapPromise("some-key", "MyPlugin", (arg) => { /* ... */ });
-```
-
-``` js
-const hook = keyedHook.get("some-key");
-if(hook !== undefined) {
-	hook.callAsync("arg", err => { /* ... */ });
-}
-```
-
-## Hook/HookMap interface
-
-Public:
-
-``` ts
-interface Hook {
-	tap: (name: string | Tap, fn: (context?, ...args) => Result) => void,
-	tapAsync: (name: string | Tap, fn: (context?, ...args, callback: (err, result: Result) => void) => void) => void,
-	tapPromise: (name: string | Tap, fn: (context?, ...args) => Promise<Result>) => void,
-	intercept: (interceptor: HookInterceptor) => void
-}
-
-interface HookInterceptor {
-	call: (context?, ...args) => void,
-	loop: (context?, ...args) => void,
-	tap: (context?, tap: Tap) => void,
-	register: (tap: Tap) => Tap,
-	context: boolean
-}
-
-interface HookMap {
-	for: (key: any) => Hook,
-	tap: (key: any, name: string | Tap, fn: (context?, ...args) => Result) => void,
-	tapAsync: (key: any, name: string | Tap, fn: (context?, ...args, callback: (err, result: Result) => void) => void) => void,
-	tapPromise: (key: any, name: string | Tap, fn: (context?, ...args) => Promise<Result>) => void,
-	intercept: (interceptor: HookMapInterceptor) => void
-}
-
-interface HookMapInterceptor {
-	factory: (key: any, hook: Hook) => Hook
-}
-
-interface Tap {
-	name: string,
-	type: string
-	fn: Function,
-	stage: number,
-	context: boolean
-}
-```
-
-Protected (only for the class containing the hook):
-
-``` ts
-interface Hook {
-	isUsed: () => boolean,
-	call: (...args) => Result,
-	promise: (...args) => Promise<Result>,
-	callAsync: (...args, callback: (err, result: Result) => void) => void,
-}
-
-interface HookMap {
-	get: (key: any) => Hook | undefined,
-	for: (key: any) => Hook
-}
-```
-
-## MultiHook
-
-A helper Hook-like class to redirect taps to multiple other hooks:
-
-``` js
-const { MultiHook } = require("tapable");
-
-this.hooks.allHooks = new MultiHook([this.hooks.hookA, this.hooks.hookB]);
-```
diff --git a/node_modules/tapable/lib/Tapable.js b/node_modules/tapable/lib/Tapable.js
deleted file mode 100644
index 530fea356..000000000
--- a/node_modules/tapable/lib/Tapable.js
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
-	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/package.json b/node_modules/tapable/package.json
deleted file mode 100644
index bb232aee6..000000000
--- a/node_modules/tapable/package.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-  "name": "tapable",
-  "version": "1.1.0",
-  "author": "Tobias Koppers @sokra",
-  "description": "Just a little module for plugins.",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "http://github.com/webpack/tapable.git"
-  },
-  "devDependencies": {
-    "babel-core": "^6.26.0",
-    "babel-jest": "^21.0.2",
-    "babel-polyfill": "^6.26.0",
-    "babel-preset-env": "^1.6.0",
-    "codecov": "^2.3.0",
-    "jest": "^21.0.4",
-    "prettier": "^1.13.2"
-  },
-  "engines": {
-    "node": ">=6"
-  },
-  "files": [
-    "lib"
-  ],
-  "homepage": "https://github.com/webpack/tapable",
-  "main": "lib/index.js",
-  "scripts": {
-    "test": "jest",
-    "travis": "jest --coverage && codecov",
-    "pretty": "prettier --write lib/*.js lib/__tests__/*.js"
-  },
-  "jest": {
-    "transform": {
-      "__tests__[\\\\/].+\\.js$": "babel-jest"
-    }
-  }
-}