smock 0.1.207 → 0.1.208

data/node_modules/webpack/lib/Template.js

@@ -0,0 +1,96 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var Tapable = require("tapable");
+var ConcatSource = require("webpack-core/lib/ConcatSource");
+
+function Template(outputOptions) {
+	Tapable.call(this);
+	this.outputOptions = outputOptions || {};
+}
+module.exports = Template;
+
+Template.getFunctionContent = function(fn) {
+	return fn.toString().replace(/^function\s?\(\)\s?\{\n?|\n?\}$/g, "").replace(/^\t/mg, "");
+};
+
+Template.toIdentifier = function(str) {
+	return str.replace(/^[^a-zA-Z$_]/,"_").replace(/[^a-zA-Z0-9$_]/g, "_");
+};
+
+Template.prototype = Object.create(Tapable.prototype);
+
+Template.prototype.indent = function indent(str) {
+	if(Array.isArray(str)) {
+		return str.map(indent).join("\n");
+	} else {
+		str = str.trimRight();
+		if(!str) return "";
+		return (str[0] === "\n" ? "" : "\t") + str.replace(/\n([^\n])/g, "\n\t$1");
+	}
+};
+
+Template.prototype.prefix = function(str, prefix) {
+	if(Array.isArray(str)) {
+		str = str.join("\n");
+	}
+	str = str.trim();
+	if(!str) return "";
+	return (str[0] === "\n" ? "" : prefix) + str.replace(/\n([^\n])/g, "\n" + prefix + "$1");
+};
+
+Template.prototype.asString = function(str) {
+	if(Array.isArray(str)) {
+		return str.join("\n");
+	}
+	return str;
+};
+
+Template.prototype.renderChunkModules = function(chunk, moduleTemplate, dependencyTemplates, prefix) {
+	if(!prefix) prefix = "";
+	var source = new ConcatSource();
+	if(chunk.modules.length === 0) {
+		source.add("[]");
+		return source;
+	}
+	var maxId = chunk.modules[chunk.modules.length - 1].id;
+	var minId = chunk.modules[0].id;
+	if(minId < 16 + ("" + minId).length) {
+		minId = 0;
+	}
+	var objectOverhead = chunk.modules.map(function(module) {
+		return (module.id + "").length + 2;
+	}).reduce(function(a, b) { return a + b; }, -1);
+	var arrayOverhead = minId === 0 ? maxId : 16 + ("" + minId).length + maxId;
+	if(arrayOverhead < objectOverhead) {
+		// Render a sparse array
+		if(minId !== 0) source.add("Array(" + minId + ").concat(");
+		source.add("[\n");
+		var modules = {};
+		chunk.modules.forEach(function(module) {
+			modules[module.id] = module;
+		});
+		for(var idx = minId; idx <= maxId; idx++) {
+			var module = modules[idx];
+			if(idx !== minId) source.add(",\n");
+			source.add("/* " + idx + " */");
+			if(module) {
+				source.add("\n");
+				source.add(moduleTemplate.render(module, dependencyTemplates, chunk));
+			}
+		}
+		source.add("\n" + prefix + "]");
+		if(minId !== 0) source.add(")");
+	} else {
+		// Render an object
+		source.add("{\n");
+		chunk.modules.forEach(function(module, idx) {
+			if(idx !== 0) source.add(",\n");
+			source.add("\n/***/ " + module.id + ":\n");
+			source.add(moduleTemplate.render(module, dependencyTemplates, chunk));
+		});
+		source.add("\n\n" + prefix + "}");
+	}
+	return source;
+};

data/node_modules/webpack/lib/TemplatedPathPlugin.js

@@ -0,0 +1,98 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Jason Anderson @diurnalist
+*/
+
+var REGEXP_HASH = /\[hash(?::(\d+))?\]/gi,
+	REGEXP_CHUNKHASH = /\[chunkhash(?::(\d+))?\]/gi,
+	REGEXP_NAME = /\[name\]/gi,
+	REGEXP_ID = /\[id\]/gi,
+	REGEXP_FILE = /\[file\]/gi,
+	REGEXP_QUERY = /\[query\]/gi,
+	REGEXP_FILEBASE = /\[filebase\]/gi;
+
+// Using global RegExp for .test is dangerous
+// We use a normal RegExp instead of .test
+var REGEXP_HASH_FOR_TEST = new RegExp(REGEXP_HASH.source, "i"),
+	REGEXP_CHUNKHASH_FOR_TEST = new RegExp(REGEXP_CHUNKHASH.source, "i"),
+	REGEXP_NAME_FOR_TEST = new RegExp(REGEXP_NAME.source, "i");
+
+// Backwards compatibility; expose regexes on Template object
+var Template = require("./Template");
+Template.REGEXP_HASH = REGEXP_HASH;
+Template.REGEXP_CHUNKHASH = REGEXP_CHUNKHASH;
+Template.REGEXP_NAME = REGEXP_NAME;
+Template.REGEXP_ID = REGEXP_ID;
+Template.REGEXP_FILE = REGEXP_FILE;
+Template.REGEXP_QUERY = REGEXP_QUERY;
+Template.REGEXP_FILEBASE = REGEXP_FILEBASE;
+
+function TemplatedPathPlugin() {}
+
+module.exports = TemplatedPathPlugin;
+
+function withHashLength(replacer, handlerFn) {
+	return function (_, hashLength) {
+		var length = hashLength && parseInt(hashLength, 10);
+		if(length && handlerFn) {
+			return handlerFn(length);
+		}
+		var hash = replacer.apply(this, arguments);
+		return length ? hash.slice(0, length) : hash;
+	};
+}
+
+function getReplacer(value, allowEmpty) {
+	return function (match) {
+		// last argument in replacer is the entire input string
+		var input = arguments[arguments.length - 1];
+		if (value == null) {
+			if (!allowEmpty) throw new Error("Path variable " + match + " not implemented in this context: " + input);
+			return "";
+		} else {
+			return "" + value;
+		}
+	};
+}
+
+function replacePathVariables(path, data) {
+	var chunk = data.chunk;
+	var chunkId = chunk && chunk.id;
+	var chunkName = chunk && (chunk.name || chunk.id);
+	var chunkHash = chunk && (chunk.renderedHash || chunk.hash);
+	var chunkHashWithLength = chunk && chunk.hashWithLength;
+
+	return path
+		.replace(REGEXP_HASH, withHashLength(getReplacer(data.hash), data.hashWithLength))
+		.replace(REGEXP_CHUNKHASH, withHashLength(getReplacer(chunkHash), chunkHashWithLength))
+		.replace(REGEXP_ID, getReplacer(chunkId))
+		.replace(REGEXP_NAME, getReplacer(chunkName))
+		.replace(REGEXP_FILE, getReplacer(data.filename))
+		.replace(REGEXP_FILEBASE, getReplacer(data.basename))
+		// query is optional, it's OK if it's in a path but there's nothing to replace it with
+		.replace(REGEXP_QUERY, getReplacer(data.query, true));
+}
+
+TemplatedPathPlugin.prototype.constructor = TemplatedPathPlugin;
+TemplatedPathPlugin.prototype.apply = function(compiler) {
+	compiler.plugin("compilation", function(compilation) {
+		var mainTemplate = compilation.mainTemplate;
+
+		mainTemplate.plugin("asset-path", replacePathVariables);
+
+		mainTemplate.plugin("global-hash", function(chunk, paths) {
+			var outputOptions = this.outputOptions;
+			var publicPath = outputOptions.publicPath || "";
+			var filename = outputOptions.filename || "";
+			var chunkFilename = outputOptions.chunkFilename || "";
+			if(REGEXP_HASH_FOR_TEST.test(publicPath) || REGEXP_CHUNKHASH_FOR_TEST.test(publicPath) || REGEXP_NAME_FOR_TEST.test(publicPath))
+				return true;
+			if(REGEXP_HASH_FOR_TEST.test(filename))
+				return true;
+			if(REGEXP_HASH_FOR_TEST.test(chunkFilename) || REGEXP_CHUNKHASH_FOR_TEST.test(chunkFilename) || REGEXP_NAME_FOR_TEST.test(chunkFilename))
+				return true;
+			if(REGEXP_HASH_FOR_TEST.test(paths.join("|")))
+				return true;
+		});
+	});
+};

data/node_modules/webpack/lib/UmdMainTemplatePlugin.js

@@ -0,0 +1,131 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var ConcatSource = require("webpack-core/lib/ConcatSource");
+var OriginalSource = require("webpack-core/lib/OriginalSource");
+
+function accessorToObjectAccess(accessor) {
+	return accessor.map(function(a) {
+		return "[" + JSON.stringify(a) + "]";
+	}).join("");
+}
+
+function accessorAccess(base, accessor) {
+	accessor = [].concat(accessor);
+	return accessor.map(function(a, idx) {
+		a = base + accessorToObjectAccess(accessor.slice(0, idx + 1));
+		if(idx === accessor.length - 1) return a;
+		return a + " = " + a + " || {}";
+	}).join(", ");
+}
+
+function UmdMainTemplatePlugin(name, optionalAmdExternalAsGlobal) {
+	this.name = name;
+	this.optionalAmdExternalAsGlobal = optionalAmdExternalAsGlobal;
+}
+module.exports = UmdMainTemplatePlugin;
+UmdMainTemplatePlugin.prototype.apply = function(compilation) {
+	var mainTemplate = compilation.mainTemplate;
+	compilation.templatesPlugin("render-with-entry", function(source, chunk, hash) {
+		var externals = chunk.modules.filter(function(m) {
+			return m.external;
+		});
+		var optionalExternals = [], requiredExternals = [];
+		if(this.optionalAmdExternalAsGlobal) {
+			externals.forEach(function(m) {
+				if(m.optional) {
+					optionalExternals.push(m);
+				} else {
+					requiredExternals.push(m);
+				}
+			});
+			externals = requiredExternals.concat(optionalExternals);
+		} else {
+			requiredExternals = externals;
+		}
+
+		function replaceKeys(str) {
+			return mainTemplate.applyPluginsWaterfall("asset-path", str, {
+				hash: hash,
+				chunk: chunk
+			});
+		}
+		function externalsDepsArray(modules) {
+			return "[" + replaceKeys(modules.map(function(m) {
+				return JSON.stringify(typeof m.request === "object" ? m.request.amd : m.request);
+			}).join(", ")) + "]";
+		}
+		function externalsRootArray(modules) {
+			return replaceKeys(modules.map(function(m) {
+				var request = m.request;
+				if(typeof request === "object") request = request.root;
+				return "root" + accessorToObjectAccess([].concat(request));
+			}).join(", "));
+		}
+		function externalsRequireArray(type) {
+			return replaceKeys(externals.map(function(m) {
+				var request = m.request;
+				if(typeof request === "object") request = request[type];
+				if(Array.isArray(request)) {
+					var expr = "require(" + JSON.stringify(request[0]) + ")" + accessorToObjectAccess(request.slice(1));
+				} else
+					var expr = "require(" + JSON.stringify(request) + ")";
+				if(m.optional) {
+					expr = "(function webpackLoadOptionalExternalModule() { try { return " + expr + "; } catch(e) {} }())";
+				}
+				return expr;
+			}).join(", "));
+		}
+		function externalsArguments(modules) {
+			return modules.map(function(m) {
+				return "__WEBPACK_EXTERNAL_MODULE_" + m.id + "__";
+			}).join(", ");
+		}
+		if(optionalExternals.length > 0) {
+			var amdFactory = "function webpackLoadOptionalExternalModuleAmd(" + externalsArguments(requiredExternals) + ") {\n" +
+			"			return factory(" + (
+				requiredExternals.length > 0 ?
+					externalsArguments(requiredExternals) + ", " + externalsRootArray(optionalExternals) :
+					externalsRootArray(optionalExternals)
+			) + ");\n" +
+			"		}";
+		} else {
+			var amdFactory = "factory";
+		}
+		return new ConcatSource(new OriginalSource(
+			"(function webpackUniversalModuleDefinition(root, factory) {\n" +
+			"	if(typeof exports === 'object' && typeof module === 'object')\n" +
+			"		module.exports = factory(" + externalsRequireArray("commonjs2") + ");\n" +
+			"	else if(typeof define === 'function' && define.amd)\n" +
+			(requiredExternals.length > 0 ?
+			"		define(" + externalsDepsArray(requiredExternals) + ", " + amdFactory + ");\n"
+			:
+			"		define(" + amdFactory + ");\n"
+			) +
+			(this.name ?
+			"	else if(typeof exports === 'object')\n" +
+			"		exports[" + JSON.stringify(replaceKeys([].concat(this.name).pop())) + "] = factory(" + externalsRequireArray("commonjs") + ");\n" +
+			"	else\n" +
+			"		" + replaceKeys(accessorAccess("root", this.name)) + " = factory(" + externalsRootArray(externals) + ");\n"
+			:
+			"	else {\n" +
+			(externals.length > 0 ?
+			"		var a = typeof exports === 'object' ? factory(" + externalsRequireArray("commonjs") + ") : factory(" + externalsRootArray(externals) + ");\n"
+			:
+			"		var a = factory();\n"
+			) +
+			"		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n" +
+			"	}\n"
+			) +
+			"})(this, function(" + externalsArguments(externals) + ") {\nreturn ", "webpack/universalModuleDefinition"), source, "\n});\n");
+	}.bind(this));
+	mainTemplate.plugin("global-hash-paths", function(paths) {
+		if (this.name) paths = paths.concat(this.name);
+		return paths;
+	}.bind(this));
+	mainTemplate.plugin("hash", function(hash) {
+		hash.update("umd");
+		hash.update(this.name + "");
+	}.bind(this));
+};

data/node_modules/webpack/lib/UnsupportedFeatureWarning.js

@@ -0,0 +1,14 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+function UnsupportedFeatureWarning(module, message) {
+	Error.call(this);
+	Error.captureStackTrace(this, UnsupportedFeatureWarning);
+	this.name = "UnsupportedFeatureWarning";
+	this.message = message;
+	this.origin = this.module = module;
+}
+module.exports = UnsupportedFeatureWarning;
+
+UnsupportedFeatureWarning.prototype = Object.create(Error.prototype);

data/node_modules/webpack/lib/WarnCaseSensitiveModulesPlugin.js

@@ -0,0 +1,28 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var CaseSensitiveModulesWarning = require("./CaseSensitiveModulesWarning");
+
+function WarnCaseSensitiveModulesPlugin() {
+}
+module.exports = WarnCaseSensitiveModulesPlugin;
+
+WarnCaseSensitiveModulesPlugin.prototype.apply = function(compiler) {
+	compiler.plugin("compilation", function(compilation) {
+		compilation.plugin("seal", function() {
+			var moduleWithoutCase = {};
+			this.modules.forEach(function(module) {
+				var ident = module.identifier().toLowerCase();
+				if(moduleWithoutCase["$"+ident]) {
+					if(moduleWithoutCase["$"+ident] !== true)
+						this.warnings.push(new CaseSensitiveModulesWarning(moduleWithoutCase["$"+ident]));
+					this.warnings.push(new CaseSensitiveModulesWarning(module));
+					moduleWithoutCase["$"+ident] = true;
+				} else {
+					moduleWithoutCase["$"+ident] = module;
+				}
+			}, this);
+		});
+	});
+};

data/node_modules/webpack/lib/WebpackOptionsApply.js

@@ -0,0 +1,371 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+var OptionsApply = require("./OptionsApply");
+
+var LoaderTargetPlugin = require("./LoaderTargetPlugin");
+var FunctionModulePlugin = require("./FunctionModulePlugin");
+var EvalDevToolModulePlugin = require("./EvalDevToolModulePlugin");
+var SourceMapDevToolPlugin = require("./SourceMapDevToolPlugin");
+var EvalSourceMapDevToolPlugin = require("./EvalSourceMapDevToolPlugin");
+
+var SingleEntryPlugin = require("./SingleEntryPlugin");
+var MultiEntryPlugin = require("./MultiEntryPlugin");
+var RecordIdsPlugin = require("./RecordIdsPlugin");
+
+var APIPlugin = require("./APIPlugin");
+var ConstPlugin = require("./ConstPlugin");
+var RequireJsStuffPlugin = require("./RequireJsStuffPlugin");
+var NodeStuffPlugin = require("./NodeStuffPlugin");
+var CompatibilityPlugin = require("./CompatibilityPlugin");
+var DefinePlugin = require("./DefinePlugin");
+
+var MovedToPluginWarningPlugin = require("./MovedToPluginWarningPlugin");
+var TemplatedPathPlugin = require("./TemplatedPathPlugin");
+var WarnCaseSensitiveModulesPlugin = require("./WarnCaseSensitiveModulesPlugin");
+
+var LoaderPlugin = require("./dependencies/LoaderPlugin");
+var CommonJsPlugin = require("./dependencies/CommonJsPlugin");
+var AMDPlugin = require("./dependencies/AMDPlugin");
+var LabeledModulesPlugin = require("./dependencies/LabeledModulesPlugin");
+var RequireContextPlugin = require("./dependencies/RequireContextPlugin");
+var RequireEnsurePlugin = require("./dependencies/RequireEnsurePlugin");
+var RequireIncludePlugin = require("./dependencies/RequireIncludePlugin");
+
+var RemoveParentModulesPlugin = require("./optimize/RemoveParentModulesPlugin");
+var RemoveEmptyChunksPlugin = require("./optimize/RemoveEmptyChunksPlugin");
+var MergeDuplicateChunksPlugin = require("./optimize/MergeDuplicateChunksPlugin");
+var FlagIncludedChunksPlugin = require("./optimize/FlagIncludedChunksPlugin");
+
+var UnsafeCachePlugin = require("enhanced-resolve/lib/UnsafeCachePlugin");
+var ModulesInDirectoriesPlugin = require("enhanced-resolve/lib/ModulesInDirectoriesPlugin");
+var ModulesInRootPlugin = require("enhanced-resolve/lib/ModulesInRootPlugin");
+var ModuleTemplatesPlugin = require("enhanced-resolve/lib/ModuleTemplatesPlugin");
+var ModuleAsFilePlugin = require("enhanced-resolve/lib/ModuleAsFilePlugin");
+var ModuleAsDirectoryPlugin = require("enhanced-resolve/lib/ModuleAsDirectoryPlugin");
+var ModuleAliasPlugin = require("enhanced-resolve/lib/ModuleAliasPlugin");
+var DirectoryDefaultFilePlugin = require("enhanced-resolve/lib/DirectoryDefaultFilePlugin");
+var DirectoryDescriptionFilePlugin = require("enhanced-resolve/lib/DirectoryDescriptionFilePlugin");
+var DirectoryDescriptionFileFieldAliasPlugin = require("enhanced-resolve/lib/DirectoryDescriptionFileFieldAliasPlugin");
+var FileAppendPlugin = require("enhanced-resolve/lib/FileAppendPlugin");
+var DirectoryResultPlugin = require("enhanced-resolve/lib/DirectoryResultPlugin");
+
+
+function WebpackOptionsApply() {
+	OptionsApply.call(this);
+}
+module.exports = WebpackOptionsApply;
+
+WebpackOptionsApply.prototype = Object.create(OptionsApply.prototype);
+WebpackOptionsApply.prototype.process = function(options, compiler) {
+	compiler.context = options.context;
+	if(options.plugins && Array.isArray(options.plugins)) {
+		compiler.apply.apply(compiler, options.plugins);
+	}
+	compiler.outputPath = options.output.path;
+	compiler.recordsInputPath = options.recordsInputPath || options.recordsPath;
+	compiler.recordsOutputPath = options.recordsOutputPath || options.recordsPath;
+	compiler.name = options.name;
+	if(typeof options.target === "string") {
+		switch(options.target) {
+		case "web":
+			var JsonpTemplatePlugin = require("./JsonpTemplatePlugin");
+			var NodeSourcePlugin = require("./node/NodeSourcePlugin");
+			compiler.apply(
+				new JsonpTemplatePlugin(options.output),
+				new FunctionModulePlugin(options.output),
+				new NodeSourcePlugin(options.node),
+				new LoaderTargetPlugin("web")
+			);
+			break;
+		case "webworker":
+			var WebWorkerTemplatePlugin = require("./webworker/WebWorkerTemplatePlugin");
+			var NodeSourcePlugin = require("./node/NodeSourcePlugin");
+			compiler.apply(
+				new WebWorkerTemplatePlugin(options.output),
+				new FunctionModulePlugin(options.output),
+				new NodeSourcePlugin(options.node),
+				new LoaderTargetPlugin("webworker")
+			);
+			break;
+		case "node":
+		case "async-node":
+			var NodeTemplatePlugin = require("./node/NodeTemplatePlugin");
+			var NodeTargetPlugin = require("./node/NodeTargetPlugin");
+			compiler.apply(
+				new NodeTemplatePlugin(options.output, options.target === "async-node"),
+				new FunctionModulePlugin(options.output),
+				new NodeTargetPlugin(),
+				new LoaderTargetPlugin("node")
+			);
+			break;
+		case "node-webkit":
+			var JsonpTemplatePlugin = require("./JsonpTemplatePlugin");
+			var NodeTargetPlugin = require("./node/NodeTargetPlugin");
+			var ExternalsPlugin = require("./ExternalsPlugin");
+			compiler.apply(
+				new JsonpTemplatePlugin(options.output),
+				new FunctionModulePlugin(options.output),
+				new NodeTargetPlugin(),
+				new ExternalsPlugin("commonjs", "nw.gui"),
+				new LoaderTargetPlugin("node-webkit")
+			);
+			break;
+		case "atom":
+			var NodeTemplatePlugin = require("./node/NodeTemplatePlugin");
+			var NodeTargetPlugin = require("./node/NodeTargetPlugin");
+			var ExternalsPlugin = require("./ExternalsPlugin");
+			compiler.apply(
+				new NodeTemplatePlugin(options.output, true),
+				new FunctionModulePlugin(options.output),
+				new NodeTargetPlugin(),
+				new ExternalsPlugin("commonjs", [
+					"app",
+					"auto-updater",
+					"browser-window",
+					"content-tracing",
+					"dialog",
+					"global-shortcut",
+					"ipc",
+					"menu",
+					"menu-item",
+					"power-monitor",
+					"protocol",
+					"tray",
+					"remote",
+					"web-view",
+					"clipboard",
+					"crash-reporter",
+					"screen",
+					"shell",
+				]),
+				new LoaderTargetPlugin("atom")
+			);
+			break;
+		default:
+			throw new Error("Unsupported target '" + options.target + "'.");
+		}
+	} else if(options.target !== false) {
+		options.target(compiler);
+	} else {
+		throw new Error("Unsupported target '" + options.target + "'.");
+	}
+	if(options.output.library || options.output.libraryTarget !== "var") {
+		var LibraryTemplatePlugin = require("./LibraryTemplatePlugin");
+		compiler.apply(new LibraryTemplatePlugin(options.output.library, options.output.libraryTarget));
+	}
+	if(options.externals) {
+		var ExternalsPlugin = require("./ExternalsPlugin");
+		compiler.apply(new ExternalsPlugin(options.output.libraryTarget, options.externals));
+	}
+
+	if(options.hot) {
+		compiler.apply(new MovedToPluginWarningPlugin("hot", "HotModuleReplacementPlugin"));
+		var HotModuleReplacementPlugin = require("./HotModuleReplacementPlugin");
+		compiler.apply(new HotModuleReplacementPlugin(options.output));
+	}
+
+	if(options.devtool == "eval")
+		compiler.apply(new EvalDevToolModulePlugin(null, options.output.devtoolModuleFilenameTemplate));
+	else if(options.devtool === "@eval")
+		compiler.apply(new EvalDevToolModulePlugin("//@ sourceURL=[url]", options.output.devtoolModuleFilenameTemplate));
+	else if(options.devtool === "#eval")
+		compiler.apply(new EvalDevToolModulePlugin("//# sourceURL=[url]", options.output.devtoolModuleFilenameTemplate));
+	else if(options.devtool === "#@eval")
+		compiler.apply(new EvalDevToolModulePlugin("//@ sourceURL=[url]\n//# sourceURL=[url]", options.output.devtoolModuleFilenameTemplate));
+	else if(options.devtool === "hidden-sourcemap" || options.devtool === "hidden-source-map")
+		compiler.apply(new SourceMapDevToolPlugin(options.output.sourceMapFilename, false, options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "sourcemap" || options.devtool === "source-map")
+		compiler.apply(new SourceMapDevToolPlugin(options.output.sourceMapFilename, null, options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "@sourcemap" || options.devtool === "@source-map")
+		compiler.apply(new SourceMapDevToolPlugin(options.output.sourceMapFilename, "\n/*\n//@ sourceMappingURL=[url]\n*/", options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "#sourcemap" || options.devtool === "#source-map")
+		compiler.apply(new SourceMapDevToolPlugin(options.output.sourceMapFilename, "\n//# sourceMappingURL=[url]", options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "#@sourcemap" || options.devtool === "#@source-map")
+		compiler.apply(new SourceMapDevToolPlugin(options.output.sourceMapFilename, "\n/*\n//@ sourceMappingURL=[url]\n//# sourceMappingURL=[url]\n*/", options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "inlinesourcemap" ||
+			options.devtool === "inline-sourcemap" ||
+			options.devtool === "inline-source-map")
+		compiler.apply(new SourceMapDevToolPlugin(null, null, options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "@inlinesourcemap" ||
+			options.devtool === "@inline-sourcemap" ||
+			options.devtool === "@inline-source-map")
+		compiler.apply(new SourceMapDevToolPlugin(null, "\n/*\n//@ sourceMappingURL=[url]\n*/", options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "#inlinesourcemap" ||
+			options.devtool === "#inline-sourcemap" ||
+			options.devtool === "#inline-source-map")
+		compiler.apply(new SourceMapDevToolPlugin(null, "\n//# sourceMappingURL=[url]", options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "#@inlinesourcemap" ||
+			options.devtool === "#@inline-sourcemap" ||
+			options.devtool === "#@inline-source-map")
+		compiler.apply(new SourceMapDevToolPlugin(null, "\n/*\n//@ sourceMappingURL=[url]\n//# sourceMappingURL=[url]\n*/", options.output.devtoolModuleFilenameTemplate, options.output.devtoolFallbackModuleFilenameTemplate));
+	else if(options.devtool === "evalsourcemap" ||
+			options.devtool === "eval-sourcemap" ||
+			options.devtool === "eval-source-map")
+		compiler.apply(new EvalSourceMapDevToolPlugin(null, options.output.devtoolModuleFilenameTemplate));
+	else if(options.devtool === "@evalsourcemap" ||
+			options.devtool === "@eval-sourcemap" ||
+			options.devtool === "@eval-source-map")
+		compiler.apply(new EvalSourceMapDevToolPlugin("\n/*\n//@ sourceMappingURL=[url]\n*/", options.output.devtoolModuleFilenameTemplate));
+	else if(options.devtool === "#evalsourcemap" ||
+			options.devtool === "#eval-sourcemap" ||
+			options.devtool === "#eval-source-map")
+		compiler.apply(new EvalSourceMapDevToolPlugin("\n//# sourceMappingURL=[url]", options.output.devtoolModuleFilenameTemplate));
+	else if(options.devtool === "#@evalsourcemap" ||
+			options.devtool === "#@eval-sourcemap" ||
+			options.devtool === "#@eval-source-map")
+		compiler.apply(new EvalSourceMapDevToolPlugin("\n/*\n//@ sourceMappingURL=[url]\n//# sourceMappingURL=[url]\n*/", options.output.devtoolModuleFilenameTemplate));
+
+	function itemToPlugin(item, name) {
+		if(Array.isArray(item))
+			return new MultiEntryPlugin(options.context, item, name);
+		else
+			return new SingleEntryPlugin(options.context, item, name)
+	}
+	if(typeof options.entry === "string" || Array.isArray(options.entry)) {
+		compiler.apply(itemToPlugin(options.entry, "main"));
+	} else if(typeof options.entry === "object") {
+		Object.keys(options.entry).forEach(function(name) {
+			compiler.apply(itemToPlugin(options.entry[name], name));
+		});
+	}
+
+	if(options.prefetch) {
+		compiler.apply(new MovedToPluginWarningPlugin("prefetch", "PrefetchPlugin"));
+		var PrefetchPlugin = require("./PrefetchPlugin");
+		options.prefetch.map(function(request) {
+			compiler.apply(new PrefetchPlugin(options.context, request));
+		});
+	}
+	compiler.apply(
+		new CompatibilityPlugin(),
+		new LoaderPlugin(),
+		new NodeStuffPlugin(options.node),
+		new RequireJsStuffPlugin(),
+		new APIPlugin(),
+		new ConstPlugin(),
+		new RequireIncludePlugin(),
+		new RequireEnsurePlugin(),
+		new RequireContextPlugin(options.resolve.modulesDirectories, options.resolve.extensions),
+		new AMDPlugin(options.module, options.amd || {}),
+		new CommonJsPlugin(options.module)
+	);
+
+	compiler.apply(
+		new RemoveParentModulesPlugin(),
+		new RemoveEmptyChunksPlugin(),
+		new MergeDuplicateChunksPlugin(),
+		new FlagIncludedChunksPlugin()
+	);
+
+	compiler.apply(new TemplatedPathPlugin());
+
+	compiler.apply(new RecordIdsPlugin());
+
+	compiler.apply(new WarnCaseSensitiveModulesPlugin());
+
+	if(options.optimize && options.optimize.occurenceOrder) {
+		compiler.apply(new MovedToPluginWarningPlugin("optimize.occurenceOrder", "optimize.OccurrenceOrderPlugin"));
+		var OccurrenceOrderPlugin = require("./optimize/OccurrenceOrderPlugin");
+		compiler.apply(new OccurrenceOrderPlugin(options.optimize.occurenceOrderPreferEntry));
+	}
+
+	if(options.optimize && options.optimize.minChunkSize) {
+		compiler.apply(new MovedToPluginWarningPlugin("optimize.minChunkSize", "optimize.MinChunkSizePlugin"));
+		var MinChunkSizePlugin = require("./optimize/MinChunkSizePlugin");
+		compiler.apply(new MinChunkSizePlugin(options.optimize));
+	}
+
+	if(options.optimize && options.optimize.maxChunks) {
+		compiler.apply(new MovedToPluginWarningPlugin("optimize.maxChunks", "optimize.LimitChunkCountPlugin"));
+		var LimitChunkCountPlugin = require("./optimize/LimitChunkCountPlugin");
+		compiler.apply(new LimitChunkCountPlugin(options.optimize));
+	}
+
+	if(options.optimize.minimize) {
+		compiler.apply(new MovedToPluginWarningPlugin("optimize.minimize", "optimize.UglifyJsPlugin"));
+		var UglifyJsPlugin = require("./optimize/UglifyJsPlugin");
+		if(options.optimize.minimize === true)
+			compiler.apply(new UglifyJsPlugin());
+		else
+			compiler.apply(new UglifyJsPlugin(options.optimize.minimize));
+	}
+
+	if(options.cache === undefined ? options.watch : options.cache) {
+		var CachePlugin = require("./CachePlugin");
+		compiler.apply(new CachePlugin(typeof options.cache === "object" ? options.cache : null));
+	}
+
+	if(typeof options.provide === "object") {
+		compiler.apply(new MovedToPluginWarningPlugin("provide", "ProvidePlugin"));
+		var ProvidePlugin = require("./ProvidePlugin");
+		compiler.apply(new ProvidePlugin(options.provide));
+	}
+
+	if(options.define) {
+		compiler.apply(new MovedToPluginWarningPlugin("define", "DefinePlugin"));
+		var defineObject = {};
+		if(typeof options.define === "object") {
+			Object.keys(options.define).forEach(function(key) {
+				defineObject[key] = options.define[key];
+			});
+		}
+		compiler.apply(new DefinePlugin(defineObject));
+	}
+	if(options.defineDebug !== false)
+		compiler.apply(new DefinePlugin({ DEBUG: !!options.debug }));
+
+	compiler.applyPlugins("after-plugins", compiler);
+	compiler.resolvers.normal.apply(
+		new UnsafeCachePlugin(options.resolve.unsafeCache),
+		options.resolve.packageAlias ? new DirectoryDescriptionFileFieldAliasPlugin("package.json", options.resolve.packageAlias) : function() {},
+		new ModuleAliasPlugin(options.resolve.alias),
+		makeRootPlugin("module", options.resolve.root),
+		new ModulesInDirectoriesPlugin("module", options.resolve.modulesDirectories),
+		makeRootPlugin("module", options.resolve.fallback),
+		new ModuleAsFilePlugin("module"),
+		new ModuleAsDirectoryPlugin("module"),
+		new DirectoryDescriptionFilePlugin("package.json", options.resolve.packageMains),
+		new DirectoryDefaultFilePlugin(["index"]),
+		new FileAppendPlugin(options.resolve.extensions)
+	);
+	compiler.resolvers.context.apply(
+		new UnsafeCachePlugin(options.resolve.unsafeCache),
+		new ModuleAliasPlugin(options.resolve.alias),
+		makeRootPlugin("module", options.resolve.root),
+		new ModulesInDirectoriesPlugin("module", options.resolve.modulesDirectories),
+		makeRootPlugin("module", options.resolve.fallback),
+		new ModuleAsFilePlugin("module"),
+		new ModuleAsDirectoryPlugin("module"),
+		new DirectoryResultPlugin()
+	);
+	compiler.resolvers.loader.apply(
+		new UnsafeCachePlugin(options.resolve.unsafeCache),
+		new ModuleAliasPlugin(options.resolveLoader.alias),
+		makeRootPlugin("loader-module", options.resolveLoader.root),
+		new ModulesInDirectoriesPlugin("loader-module", options.resolveLoader.modulesDirectories),
+		makeRootPlugin("loader-module", options.resolveLoader.fallback),
+		new ModuleTemplatesPlugin("loader-module", options.resolveLoader.moduleTemplates, "module"),
+		new ModuleAsFilePlugin("module"),
+		new ModuleAsDirectoryPlugin("module"),
+		new DirectoryDescriptionFilePlugin("package.json", options.resolveLoader.packageMains),
+		new DirectoryDefaultFilePlugin(["index"]),
+		new FileAppendPlugin(options.resolveLoader.extensions)
+	);
+	compiler.applyPlugins("after-resolvers", compiler);
+	return options;
+};
+
+function makeRootPlugin(name, root) {
+	if(typeof root === "string")
+		return new ModulesInRootPlugin(name, root);
+	else if(Array.isArray(root)) {
+		return function() {
+			root.forEach(function(root) {
+				this.apply(new ModulesInRootPlugin(name, root));
+			}, this);
+		}
+	}
+	return function() {};
+}