webpack 2.1.0-beta.21 → 2.1.0-beta.25

package/lib/WebpackOptionsValidationError.js

@@ -0,0 +1,186 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Gajus Kuizinas @gajus
+*/
+var webpackOptionsSchema = require("../schemas/webpackOptionsSchema.json");
+
+function WebpackOptionsValidationError(validationErrors) {
+	Error.call(this);
+	Error.captureStackTrace(this, WebpackOptionsValidationError);
+	this.name = "WebpackOptionsValidationError";
+	this.message = "Invalid configuration object. " +
+		"Webpack has been initialised using a configuration object that does not match the API schema.\n" +
+		validationErrors.map(function(err) {
+			return " - " + indent(WebpackOptionsValidationError.formatValidationError(err), "   ", false);
+		}).join("\n");
+	this.validationErrors = validationErrors;
+}
+module.exports = WebpackOptionsValidationError;
+
+WebpackOptionsValidationError.prototype = Object.create(Error.prototype);
+WebpackOptionsValidationError.prototype.constructor = WebpackOptionsValidationError;
+
+WebpackOptionsValidationError.formatValidationError = function formatValidationError(err) {
+	var dataPath = "configuration" + err.dataPath;
+	switch(err.keyword) {
+		case "additionalProperties":
+			var baseMessage = dataPath + " has an unknown property '" + err.params.additionalProperty + "'. These properties are valid:\n" +
+				getSchemaPartText(err.parentSchema);
+			if(!err.dataPath) {
+				switch(err.params.additionalProperty) {
+					case "debug":
+						return baseMessage + "\n" +
+							"The 'debug' property was removed in webpack 2.\n" +
+							"Loaders should be updated to allow passing this option via loader options in module.rules.\n" +
+							"Until loaders are updated one can use the LoaderOptionsPlugin to switch loaders into debug mode:\n" +
+							"plugins: {\n" +
+							"  new webpack.LoaderOptionsPlugin({\n" +
+							"    debug: true\n" +
+							"  })\n" +
+							"}";
+				}
+				return baseMessage + "\n" +
+					"For typos: please correct them.\n" +
+					"For loader options: webpack 2 no longer allows custom properties in configuration.\n" +
+					"  Loaders should be updated to allow passing options via loader options in module.rules.\n" +
+					"  Until loaders are updated one can use the LoaderOptionsPlugin to pass these options to the loader:\n" +
+					"  plugins: {\n" +
+					"    new webpack.LoaderOptionsPlugin({\n" +
+					"      // test: /\\.xxx$/, // may apply this only for some modules\n" +
+					"      options: {\n" +
+					"        " + err.params.additionalProperty + ": ...\n" +
+					"      }\n" +
+					"    })\n" +
+					"  }";
+			}
+			return baseMessage;
+		case "oneOf":
+		case "anyOf":
+		case "enum":
+			return dataPath + " should be one of these:\n" +
+				getSchemaPartText(err.parentSchema);
+		case "allOf":
+			return dataPath + " should be:\n" +
+				getSchemaPartText(err.parentSchema);
+		case "type":
+			switch(err.params.type) {
+				case "object":
+					return dataPath + " should be an object.";
+				case "string":
+					return dataPath + " should be a string.";
+				case "boolean":
+					return dataPath + " should be a boolean.";
+				case "number":
+					return dataPath + " should be a number.";
+			}
+			return dataPath + " should be " + err.params.type + ":\n" +
+				getSchemaPartText(err.parentSchema);
+		case "required":
+			var missingProperty = err.params.missingProperty.replace(/^\./, "");
+			return dataPath + " misses the property '" + missingProperty + "'.\n" +
+				getSchemaPartText(err.parentSchema, ["properties", missingProperty]);
+		case "minLength":
+			if(err.params.limit === 1)
+				return dataPath + " should not be empty.";
+			else
+				return dataPath + " " + err.message;
+		default:
+			return dataPath + " " + err.message + " (" + JSON.stringify(err, 0, 2) + ").\n" +
+				getSchemaPartText(err.parentSchema);
+	}
+}
+
+function getSchemaPart(path, parents, additionalPath) {
+	parents = parents || 0;
+	path = path.split("/");
+	path = path.slice(0, path.length - parents);
+	if(additionalPath) {
+		additionalPath = additionalPath.split("/");
+		path = path.concat(additionalPath);
+	}
+	var schemaPart = webpackOptionsSchema;
+	for(var i = 1; i < path.length; i++) {
+		var inner = schemaPart[path[i]];
+		if(inner)
+			schemaPart = inner;
+	}
+	return schemaPart;
+}
+
+function getSchemaPartText2(path, parents, additionalPath) {
+	var schemaPart = getSchemaPart(path, parents, additionalPath);
+	while(schemaPart.$ref) schemaPart = getSchemaPart(schemaPart.$ref);
+	var schemaText = WebpackOptionsValidationError.formatSchema(schemaPart);
+	if(schemaPart.description)
+		schemaText += "\n" + schemaPart.description;
+	return schemaText;
+}
+
+function getSchemaPartText(schemaPart, additionalPath) {
+	if(additionalPath) {
+		for(var i = 0; i < additionalPath.length; i++) {
+			var inner = schemaPart[additionalPath[i]];
+			if(inner)
+				schemaPart = inner;
+		}
+	}
+	while(schemaPart.$ref) schemaPart = getSchemaPart(schemaPart.$ref);
+	var schemaText = WebpackOptionsValidationError.formatSchema(schemaPart);
+	if(schemaPart.description)
+		schemaText += "\n" + schemaPart.description;
+	return schemaText;
+}
+
+function formatSchema(schema, prevSchemas) {
+	prevSchemas = prevSchemas || [];
+
+	function formatInnerSchema(innerSchema, addSelf) {
+		if(!addSelf) return formatSchema(innerSchema, prevSchemas);
+		if(prevSchemas.indexOf(innerSchema) >= 0) return "(recursive)";
+		return formatSchema(innerSchema, prevSchemas.concat(schema));
+	}
+	switch(schema.type) {
+		case "string":
+			return "string";
+		case "boolean":
+			return "boolean";
+		case "object":
+			if(schema.properties) {
+				var required = schema.required || [];
+				return "object { " + Object.keys(schema.properties).map(function(property) {
+					if(required.indexOf(property) < 0) return property + "?";
+					return property;
+				}).concat(schema.additionalProperties ? ["..."] : []).join(", ") + " }";
+			}
+			if(schema.additionalProperties) {
+				return "object { <key>: " + formatInnerSchema(schema.additionalProperties) + " }";
+			}
+			return "object";
+		case "array":
+			return "[" + formatInnerSchema(schema.items) + "]";
+	}
+	switch(schema.instanceof) {
+		case "Function":
+			return "function";
+		case "RegExp":
+			return "RegExp";
+	}
+	if(schema.$ref) return formatInnerSchema(getSchemaPart(schema.$ref), true);
+	if(schema.allOf) return schema.allOf.map(formatInnerSchema).join(" & ");
+	if(schema.oneOf) return schema.oneOf.map(formatInnerSchema).join(" | ");
+	if(schema.anyOf) return schema.anyOf.map(formatInnerSchema).join(" | ");
+	if(schema.enum) return schema.enum.map(function(item) {
+		return JSON.stringify(item);
+	}).join(" | ");
+	return JSON.stringify(schema, 0, 2);
+}
+
+function indent(str, prefix, firstLine) {
+	if(firstLine) {
+		return prefix + str.replace(/\n(?!$)/g, "\n" + prefix);
+	} else {
+		return str.replace(/\n(?!$)/g, "\n" + prefix);
+	}
+}
+
+WebpackOptionsValidationError.formatSchema = formatSchema;

package/lib/dependencies/AMDPlugin.js

@@ -28,27 +28,7 @@ function AMDPlugin(options, amdOptions) {
 module.exports = AMDPlugin;
 
 AMDPlugin.prototype.apply = function(compiler) {
-	function setTypeof(expr, value) {
-		compiler.parser.plugin("evaluate typeof " + expr, function(expr) {
-			return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
-		});
-		compiler.parser.plugin("typeof " + expr, function(expr) {
-			var dep = new ConstDependency(JSON.stringify(value), expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		});
-	}
-
-	function setExpressionToModule(expr, module) {
-		compiler.parser.plugin("expression " + expr, function(expr) {
-			var dep = new AMDRequireItemDependency(module, expr.range);
-			dep.userRequest = expr;
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		});
-	}
+	var options = this.options;
 	var amdOptions = this.amdOptions;
 	compiler.plugin("compilation", function(compilation, params) {
 		var normalModuleFactory = params.normalModuleFactory;
@@ -74,41 +54,70 @@ AMDPlugin.prototype.apply = function(compiler) {
 
 		compilation.dependencyFactories.set(LocalModuleDependency, new NullFactory());
 		compilation.dependencyTemplates.set(LocalModuleDependency, new LocalModuleDependency.Template());
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(typeof parserOptions.amd !== "undefined" && !parserOptions.amd)
+				return;
+
+			function setTypeof(expr, value) {
+				parser.plugin("evaluate typeof " + expr, function(expr) {
+					return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+				});
+				parser.plugin("typeof " + expr, function(expr) {
+					var dep = new ConstDependency(JSON.stringify(value), expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+			}
+
+			function setExpressionToModule(expr, module) {
+				parser.plugin("expression " + expr, function(expr) {
+					var dep = new AMDRequireItemDependency(module, expr.range);
+					dep.userRequest = expr;
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+			}
+
+			parser.apply(
+				new AMDRequireDependenciesBlockParserPlugin(options),
+				new AMDDefineDependencyParserPlugin(options)
+			);
+			setExpressionToModule("require.amd", "!!webpack amd options");
+			setExpressionToModule("define.amd", "!!webpack amd options");
+			setExpressionToModule("define", "!!webpack amd define");
+			parser.plugin("expression __webpack_amd_options__", function() {
+				return this.state.current.addVariable("__webpack_amd_options__", JSON.stringify(amdOptions));
+			});
+			parser.plugin("evaluate typeof define.amd", function(expr) {
+				return new BasicEvaluatedExpression().setString(typeof amdOptions).setRange(expr.range);
+			});
+			parser.plugin("evaluate typeof require.amd", function(expr) {
+				return new BasicEvaluatedExpression().setString(typeof amdOptions).setRange(expr.range);
+			});
+			parser.plugin("evaluate Identifier define.amd", function(expr) {
+				return new BasicEvaluatedExpression().setBoolean(true).setRange(expr.range);
+			});
+			parser.plugin("evaluate Identifier require.amd", function(expr) {
+				return new BasicEvaluatedExpression().setBoolean(true).setRange(expr.range);
+			});
+			setTypeof("define", "function");
+			parser.plugin("can-rename define", function() {
+				return true;
+			});
+			parser.plugin("rename define", function(expr) {
+				var dep = new AMDRequireItemDependency("!!webpack amd define", expr.range);
+				dep.userRequest = "define";
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return false;
+			});
+			setTypeof("require", "function");
+		});
 	});
-	compiler.parser.apply(
-		new AMDRequireDependenciesBlockParserPlugin(this.options),
-		new AMDDefineDependencyParserPlugin(this.options)
-	);
-	setExpressionToModule("require.amd", "!!webpack amd options");
-	setExpressionToModule("define.amd", "!!webpack amd options");
-	setExpressionToModule("define", "!!webpack amd define");
-	compiler.parser.plugin("expression __webpack_amd_options__", function() {
-		return this.state.current.addVariable("__webpack_amd_options__", JSON.stringify(amdOptions));
-	});
-	compiler.parser.plugin("evaluate typeof define.amd", function(expr) {
-		return new BasicEvaluatedExpression().setString(typeof amdOptions).setRange(expr.range);
-	});
-	compiler.parser.plugin("evaluate typeof require.amd", function(expr) {
-		return new BasicEvaluatedExpression().setString(typeof amdOptions).setRange(expr.range);
-	});
-	compiler.parser.plugin("evaluate Identifier define.amd", function(expr) {
-		return new BasicEvaluatedExpression().setBoolean(true).setRange(expr.range);
-	});
-	compiler.parser.plugin("evaluate Identifier require.amd", function(expr) {
-		return new BasicEvaluatedExpression().setBoolean(true).setRange(expr.range);
-	});
-	setTypeof("define", "function");
-	compiler.parser.plugin("can-rename define", function() {
-		return true;
-	});
-	compiler.parser.plugin("rename define", function(expr) {
-		var dep = new AMDRequireItemDependency("!!webpack amd define", expr.range);
-		dep.userRequest = "define";
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return false;
-	});
-	setTypeof("require", "function");
 	compiler.resolvers.normal.apply(
 		new AliasPlugin("described-resolve", {
 			name: "amdefine",

package/lib/dependencies/CommonJsPlugin.js

@@ -23,17 +23,7 @@ function CommonJsPlugin(options) {
 module.exports = CommonJsPlugin;
 
 CommonJsPlugin.prototype.apply = function(compiler) {
-	function setTypeof(expr, value) {
-		compiler.parser.plugin("evaluate typeof " + expr, function(expr) {
-			return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
-		});
-		compiler.parser.plugin("typeof " + expr, function(expr) {
-			var dep = new ConstDependency(JSON.stringify(value), expr.range);
-			dep.loc = expr.loc;
-			this.state.current.addDependency(dep);
-			return true;
-		});
-	}
+	var options = this.options;
 	compiler.plugin("compilation", function(compilation, params) {
 		var normalModuleFactory = params.normalModuleFactory;
 		var contextModuleFactory = params.contextModuleFactory;
@@ -55,39 +45,59 @@ CommonJsPlugin.prototype.apply = function(compiler) {
 
 		compilation.dependencyFactories.set(RequireHeaderDependency, new NullFactory());
 		compilation.dependencyTemplates.set(RequireHeaderDependency, new RequireHeaderDependency.Template());
+
+		params.normalModuleFactory.plugin("parser", function(parser, parserOptions) {
+
+			if(typeof parserOptions.commonjs !== "undefined" && !parserOptions.commonjs)
+				return;
+
+			function setTypeof(expr, value) {
+				parser.plugin("evaluate typeof " + expr, function(expr) {
+					return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+				});
+				parser.plugin("typeof " + expr, function(expr) {
+					var dep = new ConstDependency(JSON.stringify(value), expr.range);
+					dep.loc = expr.loc;
+					this.state.current.addDependency(dep);
+					return true;
+				});
+			}
+
+			setTypeof("require", "function");
+			setTypeof("require.resolve", "function");
+			setTypeof("require.resolveWeak", "function");
+			parser.plugin("evaluate typeof module", function(expr) {
+				return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
+			});
+			parser.plugin("assign require", function(expr) {
+				// to not leak to global "require", we need to define a local require here.
+				var dep = new ConstDependency("var require;", 0);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				this.scope.definitions.push("require");
+				return true;
+			});
+			parser.plugin("can-rename require", function() {
+				return true;
+			});
+			parser.plugin("rename require", function(expr) {
+				// define the require variable. It's still undefined, but not "not defined".
+				var dep = new ConstDependency("var require;", 0);
+				dep.loc = expr.loc;
+				this.state.current.addDependency(dep);
+				return false;
+			});
+			parser.plugin("typeof module", function() {
+				return true;
+			});
+			parser.plugin("evaluate typeof exports", function(expr) {
+				return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
+			});
+			parser.apply(
+				new CommonJsRequireDependencyParserPlugin(options),
+				new RequireResolveDependencyParserPlugin(options)
+			);
+		});
 	});
-	setTypeof("require", "function");
-	setTypeof("require.resolve", "function");
-	setTypeof("require.resolveWeak", "function");
-	compiler.parser.plugin("evaluate typeof module", function(expr) {
-		return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
-	});
-	compiler.parser.plugin("assign require", function(expr) {
-		// to not leak to global "require", we need to define a local require here.
-		var dep = new ConstDependency("var require;", 0);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		this.scope.definitions.push("require");
-		return true;
-	});
-	compiler.parser.plugin("can-rename require", function() {
-		return true;
-	});
-	compiler.parser.plugin("rename require", function(expr) {
-		// define the require variable. It's still undefined, but not "not defined".
-		var dep = new ConstDependency("var require;", 0);
-		dep.loc = expr.loc;
-		this.state.current.addDependency(dep);
-		return false;
-	});
-	compiler.parser.plugin("typeof module", function() {
-		return true;
-	});
-	compiler.parser.plugin("evaluate typeof exports", function(expr) {
-		return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
-	});
-	compiler.parser.apply(
-		new CommonJsRequireDependencyParserPlugin(this.options),
-		new RequireResolveDependencyParserPlugin(this.options)
-	);
+
 };

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -16,6 +16,12 @@ HarmonyExportExpressionDependency.prototype = Object.create(NullDependency.proto
 HarmonyExportExpressionDependency.prototype.constructor = HarmonyExportExpressionDependency;
 HarmonyExportExpressionDependency.prototype.type = "harmony export expression";
 
+HarmonyExportExpressionDependency.prototype.getExports = function() {
+	return {
+		exports: ["default"]
+	};
+};
+
 HarmonyExportExpressionDependency.prototype.describeHarmonyExport = function() {
 	return {
 		exportedName: "default",

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -31,10 +31,26 @@ HarmonyExportImportedSpecifierDependency.prototype.getReference = function() {
 		if(Array.isArray(this.originModule.usedExports)) {
 			// reexport * with known used exports
 			var activeExports = HarmonyModulesHelpers.getActiveExports(this.originModule);
+			if(Array.isArray(m.providedExports)) {
+				return {
+					module: m,
+					importedNames: this.originModule.usedExports.filter(function(id) {
+						return activeExports.indexOf(id) < 0 && m.providedExports.indexOf(id) >= 0 && id !== "default";
+					}, this)
+				}
+			} else {
+				return {
+					module: m,
+					importedNames: this.originModule.usedExports.filter(function(id) {
+						return activeExports.indexOf(id) < 0 && id !== "default";
+					}, this)
+				}
+			}
+		} else if(Array.isArray(m.providedExports)) {
 			return {
 				module: m,
-				importedNames: this.originModule.usedExports.filter(function(id) {
-					return activeExports.indexOf(id) < 0;
+				importedNames: m.providedExports.filter(function(id) {
+					return id !== "default"
 				})
 			}
 		} else {
@@ -61,6 +77,36 @@ HarmonyExportImportedSpecifierDependency.prototype.getReference = function() {
 	}
 };
 
+HarmonyExportImportedSpecifierDependency.prototype.getExports = function() {
+	if(this.name) {
+		return {
+			exports: [this.name]
+		}
+	};
+	if(this.importDependency.module && Array.isArray(this.importDependency.module.providedExports)) {
+		return {
+			exports: this.importDependency.module.providedExports.filter(function(id) {
+				return id !== "default"
+			}),
+			dependencies: [this.importDependency.module]
+		};
+	}
+	if(this.importDependency.module && this.importDependency.module.providedExports) {
+		return {
+			exports: true
+		};
+	}
+	if(this.importDependency.module) {
+		return {
+			exports: null,
+			dependencies: [this.importDependency.module]
+		};
+	}
+	return {
+		exports: null
+	}
+};
+
 HarmonyExportImportedSpecifierDependency.prototype.describeHarmonyExport = function() {
 	return {
 		exportedName: this.name,
@@ -71,7 +117,7 @@ HarmonyExportImportedSpecifierDependency.prototype.describeHarmonyExport = funct
 HarmonyExportImportedSpecifierDependency.prototype.updateHash = function(hash) {
 	NullDependency.prototype.updateHash.call(this, hash);
 	var importedModule = this.importDependency.module;
-	hash.update((importedModule && (importedModule.used + JSON.stringify(importedModule.usedExports))) + "");
+	hash.update((importedModule && (importedModule.used + JSON.stringify(importedModule.usedExports) + JSON.stringify(importedModule.providedExports))) + "");
 };
 
 HarmonyExportImportedSpecifierDependency.Template = function HarmonyExportImportedSpecifierDependencyTemplate() {};
@@ -83,43 +129,57 @@ HarmonyExportImportedSpecifierDependency.Template.prototype.apply = function(dep
 	var active = HarmonyModulesHelpers.isActive(dep.originModule, dep);
 	var content;
 	var activeExports;
+	var items;
+	var importIsHarmony = importedModule && (!importedModule.meta || importedModule.meta.harmonyModule);
 
 	function getReexportStatement(key, valueKey) {
 		return(importIsHarmony || !valueKey ? "" : "if(__webpack_require__.o(" + name + ", " + valueKey + ")) ") +
 			"__webpack_require__.d(exports, " + key + ", " +
-			"function() { return " + name + (valueKey === null ? "_default.a" : valueKey && "[" + valueKey + "]") + "; });"
+			"function() { return " + name + (valueKey === null ? "_default.a" : valueKey && "[" + valueKey + "]") + "; });\n"
 	}
 	if(!used) { // we want to rexport something, but the export isn't used
 		content = "/* unused harmony reexport " + dep.name + " */\n";
 	} else if(!active) { // we want to reexport something but another exports overrides this one
 		content = "/* inactive harmony reexport " + (dep.name || "namespace") + " */\n";
 	} else if(dep.name && dep.id === "default" && !(importedModule && (!importedModule.meta || importedModule.meta.harmonyModule))) { // we want to reexport the default export from a non-hamory module
-		content = "/* harmony reexport */ " + getReexportStatement(JSON.stringify(used), null) + "\n";
+		content = "/* harmony reexport (default from non-hamory) */ " + getReexportStatement(JSON.stringify(used), null);
 	} else if(dep.name && dep.id) { // we want to reexport a key as new key
 		var idUsed = importedModule && importedModule.isUsed(dep.id);
-		content = "/* harmony reexport */ " + getReexportStatement(JSON.stringify(used), JSON.stringify(idUsed)) + "\n";
+		content = "/* harmony reexport (binding) */ " + getReexportStatement(JSON.stringify(used), JSON.stringify(idUsed));
 	} else if(dep.name) { // we want to reexport the module object as named export
-		content = "/* harmony reexport */ " + getReexportStatement(JSON.stringify(used), "") + "\n";
+		content = "/* harmony reexport (module object) */ " + getReexportStatement(JSON.stringify(used), "");
 	} else if(Array.isArray(dep.originModule.usedExports)) { // we know which exports are used
 		activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule);
-		var importIsHarmony = importedModule && (!importedModule.meta || importedModule.meta.harmonyModule);
-		var importActiveExports = importedModule && HarmonyModulesHelpers.getActiveExports(importedModule);
-		var items = dep.originModule.usedExports.map(function(id) {
+		items = dep.originModule.usedExports.map(function(id) {
 			if(id === "default") return;
 			if(activeExports.indexOf(id) >= 0) return;
-			if(importIsHarmony && !HarmonyModulesHelpers.isExportedByHarmony(importedModule, id)) return;
+			if(importedModule.isProvided(id) === false) return;
 			var exportUsed = dep.originModule.isUsed(id);
 			var idUsed = importedModule && importedModule.isUsed(id);
 			return [exportUsed, idUsed];
 		}).filter(Boolean);
 		if(items.length > 0) {
-			content = "/* harmony namespace reexport */ " + items.map(function(item) {
-				return getReexportStatement(JSON.stringify(item[0]), JSON.stringify(item[1]));
-			}).join(" ") + "\n";
+			content = items.map(function(item) {
+				return "/* harmony namespace reexport (by used) */ " + getReexportStatement(JSON.stringify(item[0]), JSON.stringify(item[1]));
+			}).join("");
 		} else content = "/* unused harmony namespace reexport */\n";
-	} else if(dep.originModule.usedExports) { // not sure which exports are used
+	} else if(dep.originModule.usedExports && importedModule && Array.isArray(importedModule.providedExports)) { // not sure which exports are used, but we know which are provided
+		activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule);
+		items = importedModule.providedExports.map(function(id) {
+			if(id === "default") return;
+			if(activeExports.indexOf(id) >= 0) return;
+			var exportUsed = dep.originModule.isUsed(id);
+			var idUsed = importedModule && importedModule.isUsed(id);
+			return [exportUsed, idUsed];
+		}).filter(Boolean);
+		if(items.length > 0) {
+			content = items.map(function(item) {
+				return "/* harmony namespace reexport (by provided) */ " + getReexportStatement(JSON.stringify(item[0]), JSON.stringify(item[1]));
+			}).join("");
+		} else content = "/* empty harmony namespace reexport */\n";
+	} else if(dep.originModule.usedExports) { // not sure which exports are used and provided
 		activeExports = HarmonyModulesHelpers.getActiveExports(dep.originModule);
-		content = "/* harmony namespace reexport */ for(var __WEBPACK_IMPORT_KEY__ in " + name + ") ";
+		content = "/* harmony namespace reexport (unknown) */ for(var __WEBPACK_IMPORT_KEY__ in " + name + ") ";
 
 		// Filter out exports which are defined by other exports
 		// and filter out default export because it cannot be reexported with *

package/lib/dependencies/HarmonyExportSpecifierDependency.js

@@ -19,6 +19,12 @@ HarmonyExportSpecifierDependency.prototype = Object.create(NullDependency.protot
 HarmonyExportSpecifierDependency.prototype.constructor = HarmonyExportSpecifierDependency;
 HarmonyExportSpecifierDependency.prototype.type = "harmony export specifier";
 
+HarmonyExportSpecifierDependency.prototype.getExports = function() {
+	return {
+		exports: [this.name]
+	}
+};
+
 HarmonyExportSpecifierDependency.prototype.describeHarmonyExport = function() {
 	return {
 		exportedName: this.name,
@@ -33,14 +39,16 @@ HarmonyExportSpecifierDependency.Template.prototype.apply = function(dep, source
 	var active = HarmonyModulesHelpers.isActive(dep.originModule, dep);
 	var content;
 	if(!used) {
-		content = "/* unused harmony export " + (dep.name || "namespace") + " */";
+		content = "/* unused harmony export " + (dep.name || "namespace") + " */\n";
 	} else if(!active) {
-		content = "/* inactive harmony export " + (dep.name || "namespace") + " */";
+		content = "/* inactive harmony export " + (dep.name || "namespace") + " */\n";
 	} else if(dep.immutable) {
-		content = "/* harmony export */ exports[" + JSON.stringify(used) + "] = " + dep.id + ";";
+		content = "/* harmony export (immutable) */ exports[" + JSON.stringify(used) + "] = " + dep.id + ";\n";
 	} else {
-		content = "\n/* harmony export */ __webpack_require__.d(exports, " + JSON.stringify(used) + ", function() { return " + dep.id + "; });";
+		content = "/* harmony export (binding) */ __webpack_require__.d(exports, " + JSON.stringify(used) + ", function() { return " + dep.id + "; });\n";
 	}
+	if(dep.position > 0)
+		content = "\n" + content;
 	source.insert(dep.position, content);
 
 };

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -30,11 +30,13 @@ HarmonyImportSpecifierDependency.prototype.getReference = function() {
 HarmonyImportSpecifierDependency.prototype.getWarnings = function() {
 	var importedModule = this.importDependency.module;
 	if(importedModule && importedModule.meta && importedModule.meta.harmonyModule) {
-		if(this.id && !HarmonyModulesHelpers.isExportedByHarmony(importedModule, this.id)) {
+		if(this.id && importedModule.isProvided(this.id) === false) {
+			var err = new Error("export '" + this.id + "'" +
+				(this.id !== this.name ? " (imported as '" + this.name + "')" : "") +
+				" was not found in '" + this.importDependency.userRequest + "'");
+			err.hideStack = true;
 			return [
-				new Error("export '" + this.id + "'" +
-					(this.id !== this.name ? " (imported as '" + this.name + "')" : "") +
-					" was not found in '" + this.importDependency.userRequest + "'")
+				err
 			];
 		}
 	}

package/lib/dependencies/HarmonyModulesHelpers.js

@@ -68,32 +68,3 @@ HarmonyModulesHelpers.getActiveExports = function(module) {
 		return arr;
 	}, [])
 };
-
-HarmonyModulesHelpers.hasStarExport = function(module) {
-	if(typeof module.hasStarExport === "boolean")
-		return module.hasStarExport;
-	return module.dependencies.some(function(dep) {
-		if(!dep.describeHarmonyExport) return false;
-		var d = dep.describeHarmonyExport();
-		if(!d) return false;
-		var name = d.exportedName;
-		return !name;
-	}, [])
-};
-
-HarmonyModulesHelpers.isExportedByHarmony = function(module, exportedName) {
-	if(module.hasStarExport)
-		return exportedName !== "default";
-	if(module.activeExports && module.activeExports.indexOf(exportedName) >= 0)
-		return true;
-	if(module.activeExports && typeof module.hasStarExport === "boolean")
-		return false;
-	return module.dependencies.some(function(dep) {
-		if(!dep.describeHarmonyExport) return false;
-		var d = dep.describeHarmonyExport();
-		if(!d) return false;
-		var name = d.exportedName;
-		if(!name) return exportedName !== "default"; // namespace export
-		return name === exportedName; // direct export
-	}, [])
-};