webpack 5.99.9 → 5.100.0

package/lib/optimize/ConcatenatedModule.js

@@ -22,14 +22,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { DEFAULTS } = require("../config/defaults");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
 const JavascriptParser = require("../javascript/JavascriptParser");
+const {
+	getMakeDeferredNamespaceModeFromExportsType,
+	getOptimizedDeferredModule
+} = require("../runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
 const { concatComparators } = require("../util/comparators");
 const {
 	RESERVED_NAMES,
-	findNewName,
 	addScopeSymbols,
+	findNewName,
 	getAllReferences,
 	getPathInAst,
 	getUsedNamesInScopeInfo
@@ -154,12 +159,12 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {Map<string, string> | undefined} rawExportMap
  * @property {string=} namespaceExportSymbol
  * @property {string | undefined} namespaceObjectName
- * @property {boolean} interopNamespaceObjectUsed
- * @property {string | undefined} interopNamespaceObjectName
- * @property {boolean} interopNamespaceObject2Used
- * @property {string | undefined} interopNamespaceObject2Name
- * @property {boolean} interopDefaultAccessUsed
- * @property {string | undefined} interopDefaultAccessName
+ * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
+ * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
+ * @property {boolean} interopNamespaceObject2Used "default-only" namespace
+ * @property {string | undefined} interopNamespaceObject2Name "default-only" namespace
+ * @property {boolean} interopDefaultAccessUsed runtime namespace object that detects "__esModule"
+ * @property {string | undefined} interopDefaultAccessName runtime namespace object that detects "__esModule"
  */
 
 /**
@@ -168,13 +173,17 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
  * @property {number} index
- * @property {string | undefined} name
- * @property {boolean} interopNamespaceObjectUsed
- * @property {string | undefined} interopNamespaceObjectName
- * @property {boolean} interopNamespaceObject2Used
- * @property {string | undefined} interopNamespaceObject2Name
- * @property {boolean} interopDefaultAccessUsed
- * @property {string | undefined} interopDefaultAccessName
+ * @property {string | undefined} name module.exports / harmony namespace object
+ * @property {string | undefined} deferredName deferred module.exports / harmony namespace object
+ * @property {boolean} deferred the module is deferred at least once
+ * @property {boolean} deferredNamespaceObjectUsed deferred namespace object that being used in a not-analyzable way so it must be materialized
+ * @property {string | undefined} deferredNamespaceObjectName deferred namespace object that being used in a not-analyzable way so it must be materialized
+ * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
+ * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
+ * @property {boolean} interopNamespaceObject2Used "default-only" namespace
+ * @property {string | undefined} interopNamespaceObject2Name "default-only" namespace
+ * @property {boolean} interopDefaultAccessUsed runtime namespace object that detects "__esModule"
+ * @property {string | undefined} interopDefaultAccessName runtime namespace object that detects "__esModule"
  */
 
 /**
@@ -219,6 +228,14 @@ const compareNumbers = (a, b) => {
 };
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
 const byRangeStart = createComparator("rangeStart", compareNumbers);
+const moveDeferToLast = (
+	/** @type {{ defer?: boolean }} */ a,
+	/** @type {{ defer?: boolean }} */ b
+) => {
+	if (a.defer === b.defer) return 0;
+	if (a.defer) return 1;
+	return -1;
+};
 
 /**
  * @param {Iterable<string>} iterable iterable object
@@ -257,6 +274,7 @@ const joinIterableWithComma = iterable => {
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
+ * @param {boolean} depDeferred the dependency is deferred
  * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
  * @param {Set<ExportInfo>} alreadyVisited alreadyVisited
@@ -272,6 +290,7 @@ const getFinalBinding = (
 	runtimeTemplate,
 	neededNamespaceObjects,
 	asCall,
+	depDeferred,
 	strictHarmonyModule,
 	asiSafe,
 	alreadyVisited = new Set()
@@ -280,21 +299,36 @@ const getFinalBinding = (
 		moduleGraph,
 		strictHarmonyModule
 	);
+	const deferred =
+		depDeferred &&
+		info.type === "external" &&
+		info.deferred &&
+		!moduleGraph.isAsync(info.module);
 	if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
-				info.interopNamespaceObject2Used = true;
+				if (deferred) info.deferredNamespaceObjectUsed = true;
+				else info.interopNamespaceObject2Used = true;
 				return {
 					info,
-					rawName: /** @type {string} */ (info.interopNamespaceObject2Name),
+					rawName: /** @type {string} */ (
+						deferred
+							? info.deferredNamespaceObjectName
+							: info.interopNamespaceObject2Name
+					),
 					ids: exportName,
 					exportName
 				};
 			case "default-with-named":
-				info.interopNamespaceObjectUsed = true;
+				if (deferred) info.deferredNamespaceObjectUsed = true;
+				else info.interopNamespaceObjectUsed = true;
 				return {
 					info,
-					rawName: /** @type {string} */ (info.interopNamespaceObjectName),
+					rawName: /** @type {string} */ (
+						deferred
+							? info.deferredNamespaceObjectName
+							: info.interopNamespaceObjectName
+					),
 					ids: exportName,
 					exportName
 				};
@@ -348,6 +382,14 @@ const getFinalBinding = (
 				switch (exportName[0]) {
 					case "default": {
 						exportName = exportName.slice(1);
+						if (deferred) {
+							return {
+								info,
+								rawName: `${info.deferredName}.a`,
+								ids: exportName,
+								exportName
+							};
+						}
 						info.interopDefaultAccessUsed = true;
 						const defaultExport = asCall
 							? `${info.interopDefaultAccessName}()`
@@ -389,6 +431,15 @@ const getFinalBinding = (
 					exportName
 				};
 			case "external":
+				if (deferred) {
+					info.deferredNamespaceObjectUsed = true;
+					return {
+						info,
+						rawName: /** @type {string} */ (info.deferredNamespaceObjectName),
+						ids: exportName,
+						exportName
+					};
+				}
 				return {
 					info,
 					rawName:
@@ -480,6 +531,7 @@ const getFinalBinding = (
 					runtimeTemplate,
 					neededNamespaceObjects,
 					asCall,
+					reexport.deferred,
 					/** @type {BuildMeta} */
 					(info.module.buildMeta).strictHarmonyModule,
 					asiSafe,
@@ -519,7 +571,15 @@ const getFinalBinding = (
 			const comment = equals(used, exportName)
 				? ""
 				: Template.toNormalComment(`${exportName.join(".")}`);
-			return { info, rawName: info.name + comment, ids: used, exportName };
+			return {
+				info,
+				rawName:
+					(deferred ? info.deferredName : info.name) +
+					(deferred ? ".a" : "") +
+					comment,
+				ids: used,
+				exportName
+			};
 		}
 	}
 };
@@ -534,6 +594,7 @@ const getFinalBinding = (
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
  * @param {Set<ConcatenatedModuleInfo>} neededNamespaceObjects modules for which a namespace object should be generated
  * @param {boolean} asCall asCall
+ * @param {boolean} depDeferred the dependency is deferred
  * @param {boolean | undefined} callContext callContext
  * @param {boolean | undefined} strictHarmonyModule strictHarmonyModule
  * @param {boolean | undefined} asiSafe asiSafe
@@ -549,6 +610,7 @@ const getFinalName = (
 	runtimeTemplate,
 	neededNamespaceObjects,
 	asCall,
+	depDeferred,
 	callContext,
 	strictHarmonyModule,
 	asiSafe
@@ -563,6 +625,7 @@ const getFinalName = (
 		runtimeTemplate,
 		neededNamespaceObjects,
 		asCall,
+		depDeferred,
 		strictHarmonyModule,
 		asiSafe
 	);
@@ -701,7 +764,7 @@ class ConcatenatedModule extends Module {
 	}
 
 	get modules() {
-		return Array.from(this._modules);
+		return [...this._modules];
 	}
 
 	/**
@@ -762,9 +825,13 @@ class ConcatenatedModule extends Module {
 			cacheable: true,
 			moduleArgument,
 			exportsArgument,
+			/** @type {LazySet<string>} */
 			fileDependencies: new LazySet(),
+			/** @type {LazySet<string>} */
 			contextDependencies: new LazySet(),
+			/** @type {LazySet<string>} */
 			missingDependencies: new LazySet(),
+			/** @type {Set<string>} */
 			topLevelDeclarations: new Set(),
 			assets: undefined
 		};
@@ -775,7 +842,8 @@ class ConcatenatedModule extends Module {
 		for (const m of this._modules) {
 			// populate cacheable
 			if (!(/** @type {BuildInfo} */ (m.buildInfo).cacheable)) {
-				this.buildInfo.cacheable = false;
+				/** @type {BuildInfo} */
+				(this.buildInfo).cacheable = false;
 			}
 
 			// populate dependencies
@@ -783,7 +851,8 @@ class ConcatenatedModule extends Module {
 				dep =>
 					!(dep instanceof HarmonyImportDependency) ||
 					!this._modules.has(
-						/** @type {Module} */ (compilation.moduleGraph.getModule(dep))
+						/** @type {Module} */
+						(compilation.moduleGraph.getModule(dep))
 					)
 			)) {
 				this.dependencies.push(d);
@@ -812,38 +881,37 @@ class ConcatenatedModule extends Module {
 			const { assets, assetsInfo, topLevelDeclarations } =
 				/** @type {BuildInfo} */ (m.buildInfo);
 
+			const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+
 			// populate topLevelDeclarations
 			if (topLevelDeclarations) {
-				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
+				const topLevelDeclarations = buildInfo.topLevelDeclarations;
 				if (topLevelDeclarations !== undefined) {
 					for (const decl of topLevelDeclarations) {
 						topLevelDeclarations.add(decl);
 					}
 				}
 			} else {
-				this.buildInfo.topLevelDeclarations = undefined;
+				buildInfo.topLevelDeclarations = undefined;
 			}
 
 			// populate assets
 			if (assets) {
-				if (this.buildInfo.assets === undefined) {
-					this.buildInfo.assets = Object.create(null);
+				if (buildInfo.assets === undefined) {
+					buildInfo.assets = Object.create(null);
 				}
 				Object.assign(
 					/** @type {NonNullable<BuildInfo["assets"]>} */
-					(
-						/** @type {BuildInfo} */
-						(this.buildInfo).assets
-					),
+					(buildInfo.assets),
 					assets
 				);
 			}
 			if (assetsInfo) {
-				if (this.buildInfo.assetsInfo === undefined) {
-					this.buildInfo.assetsInfo = new Map();
+				if (buildInfo.assetsInfo === undefined) {
+					buildInfo.assetsInfo = new Map();
 				}
 				for (const [key, value] of assetsInfo) {
-					this.buildInfo.assetsInfo.set(key, value);
+					buildInfo.assetsInfo.set(key, value);
 				}
 			}
 		}
@@ -876,26 +944,28 @@ class ConcatenatedModule extends Module {
 		const list = [];
 		/** @type {Map<Module, RuntimeSpec | true>} */
 		const existingEntries = new Map();
+		const deferEnabled =
+			this.compilation && this.compilation.options.experiments.deferImport;
 
 		/**
 		 * @param {Module} module a module
 		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
 		 */
 		const getConcatenatedImports = module => {
-			const connections = Array.from(
-				moduleGraph.getOutgoingConnections(module)
-			);
+			const connections = [...moduleGraph.getOutgoingConnections(module)];
 			if (module === rootModule) {
-				for (const c of moduleGraph.getOutgoingConnections(this))
+				for (const c of moduleGraph.getOutgoingConnections(this)) {
 					connections.push(c);
+				}
 			}
 			/**
-			 * @type {Array<{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number }>}
+			 * @type {Array<{ connection: ModuleGraphConnection, sourceOrder: number, rangeStart: number, defer?: boolean }>}
 			 */
 			const references = connections
 				.filter(connection => {
-					if (!(connection.dependency instanceof HarmonyImportDependency))
+					if (!(connection.dependency instanceof HarmonyImportDependency)) {
 						return false;
+					}
 					return (
 						connection &&
 						connection.resolvedOriginModule === module &&
@@ -910,7 +980,8 @@ class ConcatenatedModule extends Module {
 					return {
 						connection,
 						sourceOrder: dep.sourceOrder,
-						rangeStart: dep.range && dep.range[0]
+						rangeStart: dep.range && dep.range[0],
+						defer: dep.defer
 					};
 				});
 			/**
@@ -925,11 +996,16 @@ class ConcatenatedModule extends Module {
 			 * a.a(); // first range
 			 * b.b(); // second range
 			 *
+			 * If the import is deferred, we always move it to the last.
 			 * If there is no reexport, we have the same source.
 			 * If there is reexport, but module has side effects, this will lead to reexport module only.
 			 * If there is side-effects-free reexport, we can get simple deterministic result with range start comparison.
 			 */
 			references.sort(concatComparators(bySourceOrder, byRangeStart));
+			if (deferEnabled) {
+				// do not combine those two sorts. defer is not the same as source or range which has a comparable number, defer is only moving them.
+				references.sort(moveDeferToLast);
+			}
 			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
 			const referencesMap = new Map();
 			for (const { connection } of references) {
@@ -974,8 +1050,9 @@ class ConcatenatedModule extends Module {
 					);
 				}
 				const imports = getConcatenatedImports(module);
-				for (const { connection, runtimeCondition } of imports)
+				for (const { connection, runtimeCondition } of imports) {
 					enterModule(connection, runtimeCondition);
+				}
 				list.push({
 					type: "concatenated",
 					module: connection.module,
@@ -1030,8 +1107,9 @@ class ConcatenatedModule extends Module {
 
 		existingEntries.set(rootModule, true);
 		const imports = getConcatenatedImports(rootModule);
-		for (const { connection, runtimeCondition } of imports)
+		for (const { connection, runtimeCondition } of imports) {
 			enterModule(connection, runtimeCondition);
+		}
 		list.push({
 			type: "concatenated",
 			module: rootModule,
@@ -1136,6 +1214,7 @@ class ConcatenatedModule extends Module {
 		// List of all used names to avoid conflicts
 		const allUsedNames = new Set(RESERVED_NAMES);
 		// Updated Top level declarations are created by renaming
+		/** @type {Set<string>} */
 		const topLevelDeclarations = new Set();
 
 		// List of additional names in scope for module references
@@ -1191,8 +1270,9 @@ class ConcatenatedModule extends Module {
 							const match = ConcatenationScope.matchModuleReference(name);
 							if (!match) continue;
 							const referencedInfo = modulesWithInfo[match.index];
-							if (referencedInfo.type === "reference")
+							if (referencedInfo.type === "reference") {
 								throw new Error("Module reference can't point to a reference");
+							}
 							const binding = getFinalBinding(
 								moduleGraph,
 								referencedInfo,
@@ -1203,6 +1283,7 @@ class ConcatenatedModule extends Module {
 								runtimeTemplate,
 								neededNamespaceObjects,
 								false,
+								match.deferredImport,
 								/** @type {BuildMeta} */
 								(info.module.buildMeta).strictHarmonyModule,
 								true
@@ -1277,9 +1358,10 @@ class ConcatenatedModule extends Module {
 							info.internalNames.set(name, newName);
 							topLevelDeclarations.add(newName);
 							const source = /** @type {ReplaceSource} */ (info.source);
-							const allIdentifiers = new Set(
-								references.map(r => r.identifier).concat(variable.identifiers)
-							);
+							const allIdentifiers = new Set([
+								...references.map(r => r.identifier),
+								...variable.identifiers
+							]);
 							for (const identifier of allIdentifiers) {
 								const r = /** @type {Range} */ (identifier.range);
 								const path = getPathInAst(
@@ -1326,7 +1408,10 @@ class ConcatenatedModule extends Module {
 					info.namespaceObjectName =
 						/** @type {string} */
 						(namespaceObjectName);
-					topLevelDeclarations.add(namespaceObjectName);
+					topLevelDeclarations.add(
+						/** @type {string} */
+						(namespaceObjectName)
+					);
 					break;
 				}
 				case "external": {
@@ -1339,6 +1424,28 @@ class ConcatenatedModule extends Module {
 					allUsedNames.add(externalName);
 					info.name = externalName;
 					topLevelDeclarations.add(externalName);
+
+					if (info.deferred) {
+						const externalName = findNewName(
+							"deferred",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(externalName);
+						info.deferredName = externalName;
+						topLevelDeclarations.add(externalName);
+
+						const externalNameInterop = findNewName(
+							"deferredNamespaceObject",
+							allUsedNames,
+							namespaceObjectUsedNames,
+							info.module.readableIdentifier(requestShortener)
+						);
+						allUsedNames.add(externalNameInterop);
+						info.deferredNamespaceObjectName = externalNameInterop;
+						topLevelDeclarations.add(externalNameInterop);
+					}
 					break;
 				}
 			}
@@ -1356,7 +1463,8 @@ class ConcatenatedModule extends Module {
 			}
 			if (
 				buildMeta.exportsType === "default" &&
-				buildMeta.defaultObject !== "redirect"
+				buildMeta.defaultObject !== "redirect" &&
+				info.interopNamespaceObject2Used
 			) {
 				const externalNameInterop = findNewName(
 					"namespaceObject2",
@@ -1390,8 +1498,9 @@ class ConcatenatedModule extends Module {
 					const match = ConcatenationScope.matchModuleReference(name);
 					if (match) {
 						const referencedInfo = modulesWithInfo[match.index];
-						if (referencedInfo.type === "reference")
+						if (referencedInfo.type === "reference") {
 							throw new Error("Module reference can't point to a reference");
+						}
 						const finalName = getFinalName(
 							moduleGraph,
 							referencedInfo,
@@ -1402,6 +1511,7 @@ class ConcatenatedModule extends Module {
 							runtimeTemplate,
 							neededNamespaceObjects,
 							match.call,
+							match.deferredImport,
 							!match.directImport,
 							/** @type {BuildMeta} */
 							(info.module.buildMeta).strictHarmonyModule,
@@ -1454,6 +1564,7 @@ class ConcatenatedModule extends Module {
 						neededNamespaceObjects,
 						false,
 						false,
+						false,
 						strictHarmonyModule,
 						true
 					);
@@ -1555,6 +1666,7 @@ class ConcatenatedModule extends Module {
 						runtimeTemplate,
 						neededNamespaceObjects,
 						false,
+						false,
 						undefined,
 						/** @type {BuildMeta} */
 						(info.module.buildMeta).strictHarmonyModule,
@@ -1574,8 +1686,9 @@ class ConcatenatedModule extends Module {
 							","
 						)}\n});\n`
 					: "";
-			if (nsObj.length > 0)
+			if (nsObj.length > 0) {
 				runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+			}
 			namespaceObjectSources.set(
 				info,
 				`
@@ -1596,7 +1709,10 @@ ${defineGetters}`
 			}
 		}
 
+		/** @type {InitFragment<ChunkRenderContext>[]} */
 		const chunkInitFragments = [];
+		const deferEnabled =
+			this.compilation && this.compilation.options.experiments.deferImport;
 
 		// evaluate modules in order
 		for (const rawInfo of modulesWithInfo) {
@@ -1608,6 +1724,31 @@ ${defineGetters}`
 					result.add(
 						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
 					);
+					// If a module is deferred in other places, but used as non-deferred here,
+					// the module itself will be emitted as mod_deferred (in the case "external"),
+					// we need to emit an extra import declaration to evaluate it in order.
+					if (deferEnabled) {
+						for (const dep of info.module.dependencies) {
+							if (
+								!dep.defer &&
+								dep instanceof HarmonyImportSideEffectDependency
+							) {
+								const referredModule = moduleGraph.getModule(dep);
+								if (!referredModule) continue;
+								if (moduleGraph.isDeferred(referredModule)) {
+									const deferredModuleInfo = /** @type {ExternalModuleInfo} */ (
+										modulesWithInfo.find(
+											i => i.type === "external" && i.module === referredModule
+										)
+									);
+									if (!deferredModuleInfo) continue;
+									result.add(
+										`\n// non-deferred import to a deferred module (${referredModule.readableIdentifier(requestShortener)})\nvar ${deferredModuleInfo.name} = ${deferredModuleInfo.deferredName}.a;`
+									);
+								}
+							}
+						}
+					}
 					result.add(/** @type {ReplaceSource} */ (info.source));
 					if (info.chunkInitFragments) {
 						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
@@ -1640,11 +1781,23 @@ ${defineGetters}`
 						isConditional = true;
 						result.add(`if (${condition}) {\n`);
 					}
-					result.add(
-						`var ${info.name} = ${RuntimeGlobals.require}(${JSON.stringify(
-							chunkGraph.getModuleId(info.module)
-						)});`
-					);
+					const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
+					if (info.deferred) {
+						const loader = getOptimizedDeferredModule(
+							runtimeTemplate,
+							info.module.getExportsType(
+								moduleGraph,
+								this.rootModule.buildMeta &&
+									this.rootModule.buildMeta.strictHarmonyModule
+							),
+							moduleId,
+							// an async module will opt-out of the concat module optimization.
+							[]
+						);
+						result.add(`var ${info.deferredName} = ${loader};`);
+					} else {
+						result.add(`var ${info.name} = __webpack_require__(${moduleId});`);
+					}
 					name = info.name;
 					break;
 				}
@@ -1652,6 +1805,18 @@ ${defineGetters}`
 					// @ts-expect-error never is expected here
 					throw new Error(`Unsupported concatenation entry type ${info.type}`);
 			}
+			if (info.type === "external" && info.deferredNamespaceObjectUsed) {
+				runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+				result.add(
+					`\nvar ${info.deferredNamespaceObjectName} = /*#__PURE__*/${
+						RuntimeGlobals.makeDeferredNamespaceObject
+					}(${JSON.stringify(
+						chunkGraph.getModuleId(info.module)
+					)}, ${getMakeDeferredNamespaceModeFromExportsType(
+						info.module.getExportsType(moduleGraph, strictHarmonyModule)
+					)});`
+				);
+			}
 			if (info.interopNamespaceObjectUsed) {
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				result.add(
@@ -1676,8 +1841,9 @@ ${defineGetters}`
 		}
 
 		const data = new Map();
-		if (chunkInitFragments.length > 0)
+		if (chunkInitFragments.length > 0) {
 			data.set("chunkInitFragments", chunkInitFragments);
+		}
 		data.set("topLevelDeclarations", topLevelDeclarations);
 
 		/** @type {CodeGenerationResult} */
@@ -1832,12 +1998,16 @@ ${defineGetters}`
 							runtimeCondition: info.runtimeCondition,
 							index,
 							name: undefined,
+							deferredName: undefined,
 							interopNamespaceObjectUsed: false,
 							interopNamespaceObjectName: undefined,
 							interopNamespaceObject2Used: false,
 							interopNamespaceObject2Name: undefined,
 							interopDefaultAccessUsed: false,
-							interopDefaultAccessName: undefined
+							interopDefaultAccessName: undefined,
+							deferred: moduleGraph.isDeferred(info.module),
+							deferredNamespaceObjectName: undefined,
+							deferredNamespaceObjectUsed: false
 						};
 						break;
 					default: