webpack 5.99.9 → 5.100.0

package/lib/optimize/MinChunkSizePlugin.js

@@ -13,7 +13,7 @@ const createSchemaValidation = require("../util/create-schema-validation");
 /** @typedef {import("../Compiler")} Compiler */
 
 const validate = createSchemaValidation(
-	require("../../schemas/plugins/optimize/MinChunkSizePlugin.check.js"),
+	require("../../schemas/plugins/optimize/MinChunkSizePlugin.check"),
 	() => require("../../schemas/plugins/optimize/MinChunkSizePlugin.json"),
 	{
 		name: "Min Chunk Size Plugin",
@@ -65,13 +65,15 @@ class MinChunkSizePlugin {
 						if (chunkGraph.getChunkSize(a, equalOptions) < minChunkSize) {
 							smallChunks.push(a);
 							for (const b of visitedChunks) {
-								if (chunkGraph.canChunksBeIntegrated(b, a))
+								if (chunkGraph.canChunksBeIntegrated(b, a)) {
 									combinations.push([b, a]);
+								}
 							}
 						} else {
 							for (const b of smallChunks) {
-								if (chunkGraph.canChunksBeIntegrated(b, a))
+								if (chunkGraph.canChunksBeIntegrated(b, a)) {
 									combinations.push([b, a]);
+								}
 							}
 						}
 						chunkSizesMap.set(a, chunkGraph.getChunkSize(a, options));
@@ -112,4 +114,5 @@ class MinChunkSizePlugin {
 		});
 	}
 }
+
 module.exports = MinChunkSizePlugin;

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -13,11 +13,11 @@ const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const {
+	filterRuntime,
 	intersectRuntime,
+	mergeRuntime,
 	mergeRuntimeOwned,
-	filterRuntime,
-	runtimeToString,
-	mergeRuntime
+	runtimeToString
 } = require("../util/runtime");
 const ConcatenatedModule = require("./ConcatenatedModule");
 
@@ -223,6 +223,11 @@ class ModuleConcatenationPlugin {
 							canBeInner = false;
 						}
 
+						if (moduleGraph.isDeferred(module)) {
+							setInnerBailoutReason(module, "Module is deferred");
+							canBeInner = false;
+						}
+
 						if (canBeRoot) relevantModules.push(module);
 						if (canBeInner) possibleInners.add(module);
 					}
@@ -585,25 +590,27 @@ class ModuleConcatenationPlugin {
 		}
 
 		// Module must be in the correct chunks
-		const missingChunks = Array.from(
-			chunkGraph.getModuleChunksIterable(config.rootModule)
-		).filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
+		const missingChunks = [
+			...chunkGraph.getModuleChunksIterable(config.rootModule)
+		].filter(chunk => !chunkGraph.isModuleInChunk(module, chunk));
 		if (missingChunks.length > 0) {
 			/**
 			 * @param {RequestShortener} requestShortener request shortener
 			 * @returns {string} problem description
 			 */
 			const problem = requestShortener => {
-				const missingChunksList = Array.from(
-					new Set(missingChunks.map(chunk => chunk.name || "unnamed chunk(s)"))
-				).sort();
-				const chunks = Array.from(
-					new Set(
-						Array.from(chunkGraph.getModuleChunksIterable(module)).map(
+				const missingChunksList = [
+					...new Set(
+						missingChunks.map(chunk => chunk.name || "unnamed chunk(s)")
+					)
+				].sort();
+				const chunks = [
+					...new Set(
+						[...chunkGraph.getModuleChunksIterable(module)].map(
 							chunk => chunk.name || "unnamed chunk(s)"
 						)
 					)
-				).sort();
+				].sort();
 				return `Module ${module.readableIdentifier(
 					requestShortener
 				)} is not in the same chunk(s) (expected in chunk(s) ${missingChunksList.join(
@@ -638,7 +645,7 @@ class ModuleConcatenationPlugin {
 					const importingExplanations = new Set(
 						activeNonModulesConnections.map(c => c.explanation).filter(Boolean)
 					);
-					const explanations = Array.from(importingExplanations).sort();
+					const explanations = [...importingExplanations].sort();
 					return `Module ${module.readableIdentifier(
 						requestShortener
 					)} is referenced ${
@@ -672,12 +679,13 @@ class ModuleConcatenationPlugin {
 				const activeConnections = connections.filter(connection =>
 					connection.isActive(runtime)
 				);
-				if (activeConnections.length > 0)
+				if (activeConnections.length > 0) {
 					incomingConnectionsFromModules.set(originModule, activeConnections);
+				}
 			}
 		}
 
-		const incomingModules = Array.from(incomingConnectionsFromModules.keys());
+		const incomingModules = [...incomingConnectionsFromModules.keys()];
 
 		// Module must be in the same chunks like the referencing module
 		const otherChunkModules = incomingModules.filter(originModule => {
@@ -718,8 +726,9 @@ class ModuleConcatenationPlugin {
 					!connection.dependency ||
 					!(connection.dependency instanceof HarmonyImportDependency)
 			);
-			if (selected.length > 0)
+			if (selected.length > 0) {
 				nonHarmonyConnections.set(originModule, connections);
+			}
 		}
 		if (nonHarmonyConnections.size > 0) {
 			/**
@@ -727,18 +736,18 @@ class ModuleConcatenationPlugin {
 			 * @returns {string} problem description
 			 */
 			const problem = requestShortener => {
-				const names = Array.from(nonHarmonyConnections)
+				const names = [...nonHarmonyConnections]
 					.map(
 						([originModule, connections]) =>
 							`${originModule.readableIdentifier(
 								requestShortener
-							)} (referenced with ${Array.from(
-								new Set(
+							)} (referenced with ${[
+								...new Set(
 									connections
 										.map(c => c.dependency && c.dependency.type)
 										.filter(Boolean)
 								)
-							)
+							]
 								.sort()
 								.join(", ")})`
 					)
@@ -898,7 +907,7 @@ class ConcatConfiguration {
 	 */
 	getWarningsSorted() {
 		return new Map(
-			Array.from(this.warnings).sort((a, b) => {
+			[...this.warnings].sort((a, b) => {
 				const ai = a[0].identifier();
 				const bi = b[0].identifier();
 				if (ai < bi) return -1;

package/lib/optimize/RealContentHashPlugin.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const { SyncBailHook } = require("tapable");
-const { RawSource, CachedSource, CompatSource } = require("webpack-sources");
+const { CachedSource, CompatSource, RawSource } = require("webpack-sources");
 const Compilation = require("../Compilation");
 const WebpackError = require("../WebpackError");
 const { compareSelect, compareStrings } = require("../util/comparators");
@@ -214,7 +214,7 @@ class RealContentHashPlugin {
 							}
 							const etag = cacheAnalyse.mergeEtags(
 								cacheAnalyse.getLazyHashedEtag(source),
-								Array.from(hashes).join("|")
+								[...hashes].join("|")
 							);
 							[asset.referencedHashes, asset.ownHashes] =
 								await cacheAnalyse.providePromise(name, etag, () => {
@@ -288,6 +288,7 @@ ${referencingAssets
 							a => a.name
 						)})`;
 					};
+					/** @type {Set<string>} */
 					const hashesInOrder = new Set();
 					for (const hash of hashToAssets.keys()) {
 						/**
@@ -316,6 +317,7 @@ ${referencingAssets
 						if (hashesInOrder.has(hash)) continue;
 						add(hash, new Set());
 					}
+					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
 					/**
 					 * @param {AssetInfoForRealContentHash} asset asset info
@@ -338,10 +340,9 @@ ${referencingAssets
 						return (asset.contentComputePromise = (async () => {
 							if (
 								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
-								Array.from(
-									/** @type {ReferencedHashes} */
-									(asset.referencedHashes)
-								).some(hash => hashToNewHash.get(hash) !== hash)
+								[
+									.../** @type {ReferencedHashes} */ (asset.referencedHashes)
+								].some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = asset.name;
 								const etag = getEtag(asset);
@@ -349,8 +350,9 @@ ${referencingAssets
 									identifier,
 									etag,
 									() => {
-										const newContent = asset.content.replace(hashRegExp, hash =>
-											hashToNewHash.get(hash)
+										const newContent = asset.content.replace(
+											hashRegExp,
+											hash => /** @type {string} */ (hashToNewHash.get(hash))
 										);
 										return new RawSource(newContent);
 									}
@@ -363,15 +365,15 @@ ${referencingAssets
 					 * @returns {Promise<void>}
 					 */
 					const computeNewContentWithoutOwn = asset => {
-						if (asset.contentComputeWithoutOwnPromise)
+						if (asset.contentComputeWithoutOwnPromise) {
 							return asset.contentComputeWithoutOwnPromise;
+						}
 						return (asset.contentComputeWithoutOwnPromise = (async () => {
 							if (
 								/** @type {OwnHashes} */ (asset.ownHashes).size > 0 ||
-								Array.from(
-									/** @type {ReferencedHashes} */
-									(asset.referencedHashes)
-								).some(hash => hashToNewHash.get(hash) !== hash)
+								[
+									.../** @type {ReferencedHashes} */ (asset.referencedHashes)
+								].some(hash => hashToNewHash.get(hash) !== hash)
 							) {
 								const identifier = `${asset.name}|without-own`;
 								const etag = getEtag(asset);
@@ -383,11 +385,12 @@ ${referencingAssets
 											hashRegExp,
 											hash => {
 												if (
-													/** @type {OwnHashes} */ (asset.ownHashes).has(hash)
+													/** @type {OwnHashes} */
+													(asset.ownHashes).has(hash)
 												) {
 													return "";
 												}
-												return hashToNewHash.get(hash);
+												return /** @type {string} */ (hashToNewHash.get(hash));
 											}
 										);
 										return new RawSource(newContent);
@@ -436,15 +439,18 @@ ${referencingAssets
 					await Promise.all(
 						assetsWithInfo.map(async asset => {
 							await computeNewContent(asset);
-							const newName = asset.name.replace(hashRegExp, hash =>
-								hashToNewHash.get(hash)
+							const newName = asset.name.replace(
+								hashRegExp,
+								hash => /** @type {string} */ (hashToNewHash.get(hash))
 							);
 
 							const infoUpdate = {};
-							const hash = asset.info.contenthash;
+							const hash = /** @type {string} */ (asset.info.contenthash);
 							infoUpdate.contenthash = Array.isArray(hash)
-								? hash.map(hash => hashToNewHash.get(hash))
-								: hashToNewHash.get(hash);
+								? hash.map(
+										hash => /** @type {string} */ (hashToNewHash.get(hash))
+									)
+								: /** @type {string} */ (hashToNewHash.get(hash));
 
 							if (asset.newSource !== undefined) {
 								compilation.updateAsset(

package/lib/optimize/RemoveEmptyChunksPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const { STAGE_BASIC, STAGE_ADVANCED } = require("../OptimizationStages");
+const { STAGE_ADVANCED, STAGE_BASIC } = require("../OptimizationStages");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
@@ -56,4 +56,5 @@ class RemoveEmptyChunksPlugin {
 		});
 	}
 }
+
 module.exports = RemoveEmptyChunksPlugin;

package/lib/optimize/RemoveParentModulesPlugin.js

@@ -203,4 +203,5 @@ class RemoveParentModulesPlugin {
 		});
 	}
 }
+
 module.exports = RemoveParentModulesPlugin;

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -8,8 +8,8 @@
 const glob2regexp = require("glob-to-regexp");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
-	JAVASCRIPT_MODULE_TYPE_ESM,
-	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
@@ -400,4 +400,5 @@ class SideEffectsFlagPlugin {
 		}
 	}
 }
+
 module.exports = SideEffectsFlagPlugin;

package/lib/optimize/SplitChunksPlugin.js

@@ -12,8 +12,8 @@ const { requestToId } = require("../ids/IdHelpers");
 const { isSubset } = require("../util/SetHelpers");
 const SortableSet = require("../util/SortableSet");
 const {
-	compareModulesByIdentifier,
-	compareIterables
+	compareIterables,
+	compareModulesByIdentifier
 } = require("../util/comparators");
 const createHash = require("../util/createHash");
 const deterministicGrouping = require("../util/deterministicGrouping");
@@ -279,10 +279,10 @@ const INITIAL_CHUNK_FILTER = chunk => chunk.canBeInitial();
  */
 const ASYNC_CHUNK_FILTER = chunk => !chunk.canBeInitial();
 /**
- * @param {Chunk} chunk the chunk
+ * @param {Chunk} _chunk the chunk
  * @returns {boolean} always true
  */
-const ALL_CHUNK_FILTER = chunk => true;
+const ALL_CHUNK_FILTER = _chunk => true;
 
 /**
  * @param {OptimizationSplitChunksSizes | undefined} value the sizes
@@ -853,7 +853,7 @@ module.exports = class SplitChunksPlugin {
 							chunk,
 							index | BigInt((Math.random() * 0x7fffffff) | 0)
 						);
-						index = index << ONE;
+						index <<= ONE;
 					}
 					/**
 					 * @param {Iterable<Chunk>} chunks list of chunks
@@ -871,7 +871,7 @@ module.exports = class SplitChunksPlugin {
 							/** @type {bigint} */ (chunkIndexMap.get(result.value));
 						while (!(result = iterator.next()).done) {
 							const raw = chunkIndexMap.get(result.value);
-							key = key ^ /** @type {bigint} */ (raw);
+							key ^= /** @type {bigint} */ (raw);
 						}
 						return key;
 					};
@@ -931,7 +931,7 @@ module.exports = class SplitChunksPlugin {
 						/** @type {Set<Chunk>} */
 						const singleChunkSets = new Set();
 						for (const module of compilation.modules) {
-							const groupedChunks = Array.from(groupChunksByExports(module));
+							const groupedChunks = [...groupChunksByExports(module)];
 							groupedByExportsMap.set(module, groupedChunks);
 							for (const chunks of groupedChunks) {
 								if (chunks.length === 1) {
@@ -1270,8 +1270,9 @@ module.exports = class SplitChunksPlugin {
 								(groupedByExportsMap.get(module));
 							for (const chunks of groupedByUsedExports) {
 								const chunksKey = getKey(chunks);
-								for (const comb of getExportsCombinations(chunksKey))
+								for (const comb of getExportsCombinations(chunksKey)) {
 									set.add(comb);
+								}
 							}
 							return set;
 						});
@@ -1489,10 +1490,11 @@ module.exports = class SplitChunksPlugin {
 						// Were some (invalid) chunks removed from usedChunks?
 						// => readd all modules to the queue, as things could have been changed
 						if (usedChunks.size < item.chunks.size) {
-							if (isExistingChunk)
+							if (isExistingChunk) {
 								usedChunks.add(/** @type {Chunk} */ (newChunk));
+							}
 							if (usedChunks.size >= item.cacheGroup.minChunks) {
-								const chunksArr = Array.from(usedChunks);
+								const chunksArr = [...usedChunks];
 								for (const module of item.modules) {
 									addModuleToChunksInfoMap(
 										item.cacheGroup,
@@ -1618,7 +1620,7 @@ module.exports = class SplitChunksPlugin {
 									: item.cacheGroup.maxInitialSize,
 								automaticNameDelimiter: item.cacheGroup.automaticNameDelimiter,
 								keys: oldMaxSizeSettings
-									? oldMaxSizeSettings.keys.concat(item.cacheGroup.key)
+									? [...oldMaxSizeSettings.keys, item.cacheGroup.key]
 									: [item.cacheGroup.key]
 							});
 						}
@@ -1672,7 +1674,7 @@ module.exports = class SplitChunksPlugin {
 
 					// Make sure that maxSize is fulfilled
 					const { fallbackCacheGroup } = this.options;
-					for (const chunk of Array.from(compilation.chunks)) {
+					for (const chunk of compilation.chunks) {
 						const chunkConfig = maxSizeQueueMap.get(chunk);
 						const {
 							minSize,
@@ -1680,8 +1682,9 @@ module.exports = class SplitChunksPlugin {
 							maxInitialSize,
 							automaticNameDelimiter
 						} = chunkConfig || fallbackCacheGroup;
-						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk))
+						if (!chunkConfig && !fallbackCacheGroup.chunksFilter(chunk)) {
 							continue;
+						}
 						/** @type {SplitChunksSizes} */
 						let maxSize;
 						if (chunk.isOnlyInitial()) {

package/lib/rules/BasicEffectRulePlugin.js

@@ -16,6 +16,8 @@
 
 /** @typedef {KeysOfTypes<RuleSetRule, string | boolean | { [k: string]: EXPECTED_ANY }>} BasicEffectRuleKeys */
 
+const PLUGIN_NAME = "BasicEffectRulePlugin";
+
 class BasicEffectRulePlugin {
 	/**
 	 * @param {BasicEffectRuleKeys} ruleProperty the rule property
@@ -32,8 +34,8 @@ class BasicEffectRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"BasicEffectRulePlugin",
-			(path, rule, unhandledProperties, result, references) => {
+			PLUGIN_NAME,
+			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);
 

package/lib/rules/BasicMatcherRulePlugin.js

@@ -20,6 +20,8 @@
 
 /** @typedef {KeysOfTypes<RuleSetRule, RuleSetConditionOrConditions | RuleSetConditionOrConditionsAbsolute>} BasicMatcherRuleKeys */
 
+const PLUGIN_NAME = "BasicMatcherRulePlugin";
+
 class BasicMatcherRulePlugin {
 	/**
 	 * @param {BasicMatcherRuleKeys} ruleProperty the rule property
@@ -38,7 +40,7 @@ class BasicMatcherRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"BasicMatcherRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(this.ruleProperty)) {
 					unhandledProperties.delete(this.ruleProperty);

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -20,6 +20,8 @@
 
 /** @typedef {KeysOfTypes<RuleSetRule, { [k: string]: RuleSetConditionOrConditions }>} ObjectMatcherRuleKeys */
 
+const PLUGIN_NAME = "ObjectMatcherRulePlugin";
+
 class ObjectMatcherRulePlugin {
 	/**
 	 * @param {ObjectMatcherRuleKeys} ruleProperty the rule property
@@ -39,7 +41,7 @@ class ObjectMatcherRulePlugin {
 	apply(ruleSetCompiler) {
 		const { ruleProperty, dataProperty } = this;
 		ruleSetCompiler.hooks.rule.tap(
-			"ObjectMatcherRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(ruleProperty)) {
 					unhandledProperties.delete(ruleProperty);

package/lib/rules/RuleSetCompiler.js

@@ -208,6 +208,7 @@ class RuleSetCompiler {
 	 * @returns {CompiledRule} normalized and compiled rule for processing
 	 */
 	compileRule(path, rule, refs) {
+		/** @type {Set<string>} */
 		const unhandledProperties = new Set(
 			Object.keys(rule).filter(
 				key => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined
@@ -227,16 +228,18 @@ class RuleSetCompiler {
 		if (unhandledProperties.has("rules")) {
 			unhandledProperties.delete("rules");
 			const rules = rule.rules;
-			if (!Array.isArray(rules))
+			if (!Array.isArray(rules)) {
 				throw this.error(path, rules, "Rule.rules must be an array of rules");
+			}
 			compiledRule.rules = this.compileRules(`${path}.rules`, rules, refs);
 		}
 
 		if (unhandledProperties.has("oneOf")) {
 			unhandledProperties.delete("oneOf");
 			const oneOf = rule.oneOf;
-			if (!Array.isArray(oneOf))
+			if (!Array.isArray(oneOf)) {
 				throw this.error(path, oneOf, "Rule.oneOf must be an array of rules");
+			}
 			compiledRule.oneOf = this.compileRules(`${path}.oneOf`, oneOf, refs);
 		}
 
@@ -244,7 +247,7 @@ class RuleSetCompiler {
 			throw this.error(
 				path,
 				rule,
-				`Properties ${Array.from(unhandledProperties).join(", ")} are unknown`
+				`Properties ${[...unhandledProperties].join(", ")} are unknown`
 			);
 		}
 

package/lib/rules/UseEffectRulePlugin.js

@@ -17,6 +17,8 @@ const util = require("util");
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
 /** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
 
+const PLUGIN_NAME = "UseEffectRulePlugin";
+
 class UseEffectRulePlugin {
 	/**
 	 * @param {RuleSetCompiler} ruleSetCompiler the rule set compiler
@@ -24,7 +26,7 @@ class UseEffectRulePlugin {
 	 */
 	apply(ruleSetCompiler) {
 		ruleSetCompiler.hooks.rule.tap(
-			"UseEffectRulePlugin",
+			PLUGIN_NAME,
 			(path, rule, unhandledProperties, result, references) => {
 				/**
 				 * @param {keyof RuleSetRule} property property

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -11,8 +11,12 @@ const HelperRuntimeModule = require("./HelperRuntimeModule");
 /** @typedef {import("../Compilation")} Compilation */
 
 class AsyncModuleRuntimeModule extends HelperRuntimeModule {
-	constructor() {
+	/**
+	 * @param {boolean=} deferInterop if defer import is used.
+	 */
+	constructor(deferInterop = false) {
 		super("async module");
+		this._deferInterop = deferInterop;
 	}
 
 	/**
@@ -22,10 +26,20 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
+		const defer = this._deferInterop;
 		return Template.asString([
-			'var webpackQueues = typeof Symbol === "function" ? Symbol("webpack queues") : "__webpack_queues__";',
-			`var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
-			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
+			'var hasSymbol = typeof Symbol === "function";',
+			'var webpackQueues = hasSymbol ? Symbol("webpack queues") : "__webpack_queues__";',
+			`var webpackExports = ${
+				defer ? `${RuntimeGlobals.asyncModuleExportSymbol}= ` : ""
+			}hasSymbol ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
+			'var webpackError = hasSymbol ? Symbol("webpack error") : "__webpack_error__";',
+			defer
+				? `var webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`
+				: "",
+			defer
+				? `var webpackDefer = ${RuntimeGlobals.makeDeferredNamespaceObjectSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`
+				: "",
 			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
 				"if(queue && queue.d < 1) {",
 				Template.indent([
@@ -45,6 +59,39 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				`deps.map(${runtimeTemplate.basicFunction("dep", [
 					'if(dep !== null && typeof dep === "object") {',
 					Template.indent([
+						defer
+							? Template.asString([
+									"if(!dep[webpackQueues] && dep[webpackDefer]) {",
+									Template.indent([
+										"var asyncDeps = dep[webpackDefer];",
+										`var hasUnresolvedAsyncSubgraph = asyncDeps.some(${runtimeTemplate.basicFunction(
+											"id",
+											[
+												"var cache = __webpack_module_cache__[id];",
+												"return !cache || cache[webpackDone] === false;"
+											]
+										)});`,
+										"if (hasUnresolvedAsyncSubgraph) {",
+										Template.indent([
+											"var d = dep;",
+											"dep = {",
+											Template.indent([
+												"then(callback) {",
+												Template.indent([
+													"Promise.all(asyncDeps.map(__webpack_require__))",
+													`.then(${runtimeTemplate.returningFunction(
+														"callback(d)"
+													)});`
+												]),
+												"}"
+											]),
+											"};"
+										]),
+										"} else return dep;"
+									]),
+									"}"
+								])
+							: "",
 						"if(dep[webpackQueues]) return dep;",
 						"if(dep.then) {",
 						Template.indent([
@@ -58,6 +105,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"resolveQueue(queue);"
 							])});`,
 							"var obj = {};",
+							defer ? "obj[webpackDefer] = false;" : "",
 							`obj[webpackQueues] = ${runtimeTemplate.expressionFunction(
 								"fn(queue)",
 								"fn"
@@ -92,11 +140,12 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 					"fn"
 				)};`,
 				"module.exports = promise;",
-				`body(${runtimeTemplate.basicFunction("deps", [
+				`var handle = ${runtimeTemplate.basicFunction("deps", [
 					"currentDeps = wrapDeps(deps);",
 					"var fn;",
 					`var getResult = ${runtimeTemplate.returningFunction(
 						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+							defer ? "if(d[webpackDefer]) return d;" : "",
 							"if(d[webpackError]) throw d[webpackError];",
 							"return d[webpackExports];"
 						])})`
@@ -114,16 +163,22 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"q"
 							)};`,
 							`currentDeps.map(${runtimeTemplate.expressionFunction(
-								"dep[webpackQueues](fnQueue)",
+								`${
+									defer ? "dep[webpackDefer]||" : ""
+								}dep[webpackQueues](fnQueue)`,
 								"dep"
 							)});`
 						]
 					)});`,
 					"return fn.r ? promise : getResult();"
-				])}, ${runtimeTemplate.expressionFunction(
-					"(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)",
+				])}`,
+				`var done = ${runtimeTemplate.expressionFunction(
+					`(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)${
+						defer ? ", promise[webpackDone] = true" : ""
+					}`,
 					"err"
-				)});`,
+				)}`,
+				"body(handle, done);",
 				"queue && queue.d < 0 && (queue.d = 0);"
 			])};`
 		]);

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -49,7 +49,7 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				`${RuntimeGlobals.makeNamespaceObject}(ns);`,
 				"var def = {};",
 				"leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];",
-				"for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
+				"for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {",
 				Template.indent([
 					`Object.getOwnPropertyNames(current).forEach(${runtimeTemplate.expressionFunction(
 						`def[key] = ${runtimeTemplate.returningFunction("value[key]", "")}`,