webpack 5.102.1 → 5.104.0

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -15,6 +15,7 @@ const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
 const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
+const { ImportPhaseUtils } = require("./ImportPhase");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
@@ -36,6 +37,7 @@ const HarmonyImportDependency = require("./HarmonyImportDependency");
 /** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
 /** @typedef {import("./HarmonyImportDependency").ExportPresenceMode} ExportPresenceMode */
 /** @typedef {HarmonyImportDependency.Ids} Ids */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 const idsSymbol = Symbol("HarmonyImportSpecifierDependency.ids");
 
@@ -49,9 +51,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 * @param {string} name name
 	 * @param {Range} range range
 	 * @param {ExportPresenceMode} exportPresenceMode export presence mode
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes | undefined} attributes import attributes
 	 * @param {IdRanges | undefined} idRanges ranges for members of ids; the two arrays are right-aligned
-	 * @param {boolean=} defer is defer phase
 	 */
 	constructor(
 		request,
@@ -60,11 +62,11 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		name,
 		range,
 		exportPresenceMode,
+		phase,
 		attributes,
-		idRanges, // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
-		defer
+		idRanges // TODO webpack 6 make this non-optional. It must always be set to properly trim ids.
 	) {
-		super(request, sourceOrder, attributes, defer);
+		super(request, sourceOrder, phase, attributes);
 		this.ids = ids;
 		this.name = name;
 		this.range = range;
@@ -440,14 +442,14 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 					connection.module,
 					{
 						asiSafe: dep.asiSafe,
-						deferredImport: dep.defer
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
 			} else if (dep.namespaceObjectAsContext && ids.length === 1) {
 				exportExpr =
 					concatenationScope.createModuleReference(connection.module, {
 						asiSafe: dep.asiSafe,
-						deferredImport: dep.defer
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}) + propertyAccess(ids);
 			} else {
 				exportExpr = concatenationScope.createModuleReference(
@@ -457,7 +459,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 						call: dep.call,
 						directImport: dep.directImport,
 						asiSafe: dep.asiSafe,
-						deferredImport: dep.defer
+						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
 			}
@@ -482,7 +484,7 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 				initFragments,
 				runtime,
 				runtimeRequirements,
-				defer: dep.defer
+				dependency: dep
 			});
 		}
 		return exportExpr;

package/lib/dependencies/ImportDependency.js

@@ -22,18 +22,21 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportDependency extends ModuleDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {RawReferencedExports | null=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
+	constructor(request, range, referencedExports, phase, attributes) {
 		super(request);
 		this.range = range;
 		this.referencedExports = referencedExports;
+		this.phase = phase;
 		this.attributes = attributes;
 	}
 
@@ -99,6 +102,7 @@ class ImportDependency extends ModuleDependency {
 	serialize(context) {
 		context.write(this.range);
 		context.write(this.referencedExports);
+		context.write(this.phase);
 		context.write(this.attributes);
 		super.serialize(context);
 	}
@@ -109,6 +113,7 @@ class ImportDependency extends ModuleDependency {
 	deserialize(context) {
 		this.range = context.read();
 		this.referencedExports = context.read();
+		this.phase = context.read();
 		this.attributes = context.read();
 		super.deserialize(context);
 	}
@@ -140,6 +145,7 @@ ImportDependency.Template = class ImportDependencyTemplate extends (
 			module: /** @type {Module} */ (moduleGraph.getModule(dep)),
 			request: dep.request,
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
+			dependency: dep,
 			message: "import()",
 			runtimeRequirements
 		});

package/lib/dependencies/ImportEagerDependency.js

@@ -16,16 +16,18 @@ const ImportDependency = require("./ImportDependency");
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {ImportDependency.RawReferencedExports} RawReferencedExports */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportEagerDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {RawReferencedExports | null=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
-		super(request, range, referencedExports, attributes);
+	constructor(request, range, referencedExports, phase, attributes) {
+		super(request, range, referencedExports, phase, attributes);
 	}
 
 	get type() {
@@ -63,6 +65,7 @@ ImportEagerDependency.Template = class ImportEagerDependencyTemplate extends (
 			request: dep.request,
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() eager",
+			dependency: dep,
 			runtimeRequirements
 		});
 

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -25,7 +25,7 @@ const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 
-/** @typedef {Pick<ContextModuleOptions, 'mode' | 'recursive' | 'regExp' | 'include' | 'exclude' | 'chunkName'> & { groupOptions: RawChunkGroupOptions, exports?: RawReferencedExports }} ImportMetaContextOptions */
+/** @typedef {Pick<ContextModuleOptions, "mode" | "recursive" | "regExp" | "include" | "exclude" | "chunkName"> & { groupOptions: RawChunkGroupOptions, exports?: RawReferencedExports }} ImportMetaContextOptions */
 
 /**
  * @param {Property} prop property

package/lib/dependencies/ImportMetaPlugin.js

@@ -6,11 +6,15 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
+const { SyncBailHook } = require("tapable");
+const Compilation = require("../Compilation");
+const DefinePlugin = require("../DefinePlugin");
 const ModuleDependencyWarning = require("../ModuleDependencyWarning");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const {
@@ -31,6 +35,8 @@ const ConstDependency = require("./ConstDependency");
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
+/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/** @typedef {import("./ConstDependency").RawRuntimeRequirements} RawRuntimeRequirements */
 
 const getCriticalDependencyWarning = memoize(() =>
 	require("./CriticalDependencyWarning")
@@ -38,7 +44,60 @@ const getCriticalDependencyWarning = memoize(() =>
 
 const PLUGIN_NAME = "ImportMetaPlugin";
 
+/**
+ * Collect import.meta.env definitions from DefinePlugin and build JSON string
+ * @param {Compilation} compilation the compilation
+ * @returns {string} env object as JSON string
+ */
+const collectImportMetaEnvDefinitions = (compilation) => {
+	const definePluginHooks = DefinePlugin.getCompilationHooks(compilation);
+	const definitions = definePluginHooks.definitions.call({});
+	if (!definitions) {
+		return "{}";
+	}
+
+	/** @type {string[]} */
+	const pairs = [];
+	for (const key of Object.keys(definitions)) {
+		if (key.startsWith("import.meta.env.")) {
+			const envKey = key.slice("import.meta.env.".length);
+			const value = definitions[key];
+			pairs.push(`${JSON.stringify(envKey)}:${value}`);
+		}
+	}
+
+	return `{${pairs.join(",")}}`;
+};
+
+/**
+ * @typedef {object} ImportMetaPluginHooks
+ * @property {SyncBailHook<[DestructuringAssignmentProperty], string | void>} propertyInDestructuring
+ */
+
+/** @type {WeakMap<Compilation, ImportMetaPluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
 class ImportMetaPlugin {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {ImportMetaPluginHooks} the attached hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				propertyInDestructuring: new SyncBailHook(["property"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
 	/**
 	 * @param {Compiler} compiler compiler
 	 */
@@ -46,6 +105,8 @@ class ImportMetaPlugin {
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				const hooks = ImportMetaPlugin.getCompilationHooks(compilation);
+
 				/**
 				 * @param {NormalModule} module module
 				 * @returns {string} file url
@@ -135,25 +196,44 @@ class ImportMetaPlugin {
 								return true;
 							}
 
+							/** @type {RawRuntimeRequirements} */
+							const runtimeRequirements = [];
+
 							let str = "";
-							for (const { id: prop } of referencedPropertiesInDestructuring) {
-								switch (prop) {
+							for (const prop of referencedPropertiesInDestructuring) {
+								const value = hooks.propertyInDestructuring.call(prop);
+
+								if (value) {
+									str += value;
+									continue;
+								}
+
+								switch (prop.id) {
 									case "url":
 										str += `url: ${importMetaUrl()},`;
 										break;
 									case "webpack":
 										str += `webpack: ${importMetaWebpackVersion()},`;
 										break;
+									case "main":
+										str += `main: ${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module},`;
+										runtimeRequirements.push(
+											RuntimeGlobals.moduleCache,
+											RuntimeGlobals.entryModuleId,
+											RuntimeGlobals.module
+										);
+										break;
 									default:
 										str += `[${JSON.stringify(
-											prop
-										)}]: ${importMetaUnknownProperty([prop])},`;
+											prop.id
+										)}]: ${importMetaUnknownProperty([prop.id])},`;
 										break;
 								}
 							}
 							const dep = new ConstDependency(
 								`({${str}})`,
-								/** @type {Range} */ (metaProperty.range)
+								/** @type {Range} */ (metaProperty.range),
+								runtimeRequirements
 							);
 							dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 							parser.state.module.addPresentationalDependency(dep);
@@ -197,17 +277,17 @@ class ImportMetaPlugin {
 						);
 
 					// import.meta.webpack
-					parser.hooks.typeof
+					parser.hooks.expression
 						.for("import.meta.webpack")
 						.tap(
 							PLUGIN_NAME,
-							toConstantDependency(parser, JSON.stringify("number"))
+							toConstantDependency(parser, importMetaWebpackVersion())
 						);
-					parser.hooks.expression
+					parser.hooks.typeof
 						.for("import.meta.webpack")
 						.tap(
 							PLUGIN_NAME,
-							toConstantDependency(parser, importMetaWebpackVersion())
+							toConstantDependency(parser, JSON.stringify("number"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("import.meta.webpack")
@@ -216,10 +296,75 @@ class ImportMetaPlugin {
 						.for("import.meta.webpack")
 						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
 
+					parser.hooks.expression
+						.for("import.meta.main")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(
+								parser,
+								`${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${RuntimeGlobals.module}`,
+								[
+									RuntimeGlobals.moduleCache,
+									RuntimeGlobals.entryModuleId,
+									RuntimeGlobals.module
+								]
+							)
+						);
+					parser.hooks.typeof
+						.for("import.meta.main")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("boolean"))
+						);
+					parser.hooks.evaluateTypeof
+						.for("import.meta.main")
+						.tap(PLUGIN_NAME, evaluateToString("boolean"));
+
+					// import.meta.env
+					parser.hooks.typeof
+						.for("import.meta.env")
+						.tap(
+							PLUGIN_NAME,
+							toConstantDependency(parser, JSON.stringify("object"))
+						);
+					parser.hooks.expression
+						.for("import.meta.env")
+						.tap(PLUGIN_NAME, (expr) => {
+							const envCode = collectImportMetaEnvDefinitions(compilation);
+							const dep = new ConstDependency(
+								envCode,
+								/** @type {Range} */ (expr.range)
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("import.meta.env")
+						.tap(PLUGIN_NAME, evaluateToString("object"));
+					parser.hooks.evaluateIdentifier
+						.for("import.meta.env")
+						.tap(PLUGIN_NAME, (expr) =>
+							new BasicEvaluatedExpression()
+								.setTruthy()
+								.setSideEffects(false)
+								.setRange(/** @type {Range} */ (expr.range))
+						);
+
 					// Unknown properties
 					parser.hooks.unhandledExpressionMemberChain
 						.for("import.meta")
 						.tap(PLUGIN_NAME, (expr, members) => {
+							// keep import.meta.env unknown property
+							// don't evaluate import.meta.env.UNKNOWN_PROPERTY -> undefined.UNKNOWN_PROPERTY
+							// `dirname` and `filename` logic in NodeStuffPlugin
+							if (
+								members[0] === "env" ||
+								members[0] === "dirname" ||
+								members[0] === "filename"
+							) {
+								return true;
+							}
 							const dep = new ConstDependency(
 								importMetaUnknownProperty(members),
 								/** @type {Range} */ (expr.range)

package/lib/dependencies/ImportParserPlugin.js

@@ -17,6 +17,7 @@ const ContextDependencyHelpers = require("./ContextDependencyHelpers");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
+const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
@@ -28,7 +29,7 @@ const ImportWeakDependency = require("./ImportWeakDependency");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../javascript/JavascriptParser").ParserState} ParserState */
+/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
 /** @typedef {import("../javascript/JavascriptParser").MembersOptionals} MembersOptionals */
 /** @typedef {import("../javascript/JavascriptParser").ArrowFunctionExpression} ArrowFunctionExpression */
@@ -40,7 +41,7 @@ const ImportWeakDependency = require("./ImportWeakDependency");
 /** @typedef {{ references: RawReferencedExports, expression: ImportExpression }} ImportSettings */
 /** @typedef {WeakMap<ImportExpression, RawReferencedExports>} State */
 
-/** @type {WeakMap<ParserState, State>} */
+/** @type {WeakMap<JavascriptParserState, State>} */
 const parserStateMap = new WeakMap();
 const dynamicImportTag = Symbol("import()");
 
@@ -311,27 +312,11 @@ class ImportParserPlugin {
 				}
 			}
 
-			let phase = expr.phase;
-			if (!phase && importOptions && importOptions.webpackDefer !== undefined) {
-				if (typeof importOptions.webpackDefer !== "boolean") {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackDefer\` expected a boolean, but received: ${importOptions.webpackDefer}.`,
-							/** @type {DependencyLocation} */ (expr.loc)
-						)
-					);
-				} else if (importOptions.webpackDefer) {
-					phase = "defer";
-				}
-			}
-			if (phase === "defer") {
-				parser.state.module.addWarning(
-					new UnsupportedFeatureWarning(
-						"import.defer() is not implemented yet.",
-						/** @type {DependencyLocation} */ (expr.loc)
-					)
-				);
-			}
+			const phase = createGetImportPhase(this.options.deferImport)(
+				parser,
+				expr,
+				() => importOptions
+			);
 
 			if (importOptions) {
 				if (importOptions.webpackIgnore !== undefined) {
@@ -533,6 +518,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					parser.state.current.addDependency(dep);
@@ -541,6 +527,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					parser.state.current.addDependency(dep);
@@ -557,6 +544,7 @@ class ImportParserPlugin {
 						/** @type {string} */ (param.string),
 						/** @type {Range} */ (expr.range),
 						exports,
+						phase,
 						attributes
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
@@ -568,6 +556,16 @@ class ImportParserPlugin {
 				if (mode === "weak") {
 					mode = "async-weak";
 				}
+
+				if (ImportPhaseUtils.isDefer(phase)) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							"import.defer() is not yet supported for ContextModule (the import path is a dynamic expression).",
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				}
+
 				const dep = ContextDependencyHelpers.create(
 					ImportContextDependency,
 					/** @type {Range} */ (expr.range),

package/lib/dependencies/ImportPhase.js

@@ -0,0 +1,121 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const memoize = require("../util/memoize");
+
+const getCommentCompilationWarning = memoize(() =>
+	require("../CommentCompilationWarning")
+);
+
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ExportNamedDeclaration} ExportNamedDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ImportDeclaration} ImportDeclaration */
+/** @typedef {import("../javascript/JavascriptParser").ImportExpression} ImportExpression */
+
+/** @typedef {typeof ImportPhase.Evaluation | typeof ImportPhase.Defer | typeof ImportPhase.Source}  ImportPhaseType */
+
+const ImportPhase = Object.freeze({
+	Evaluation: 0b00,
+	Defer: 0b01,
+	Source: 0b10
+});
+
+/**
+ * @typedef {object} ImportPhaseUtils
+ * @property {(phase: ImportPhaseType) => boolean} isDefer true if phase is defer
+ * @property {(phase: ImportPhaseType) => boolean} isSource true if phase is source
+ */
+
+/** @type {ImportPhaseUtils} */
+const ImportPhaseUtils = {
+	isDefer(phase) {
+		return phase === ImportPhase.Defer;
+	},
+	isSource(phase) {
+		return phase === ImportPhase.Source;
+	}
+};
+
+/**
+ * @typedef {() => Record<string, EXPECTED_ANY> | null} GetCommentOptions
+ */
+
+/**
+ * @callback GetImportPhase
+ * @param {JavascriptParser} parser parser
+ * @param {ExportNamedDeclaration | ExportAllDeclaration | ImportDeclaration | ImportExpression} node node
+ * @param {GetCommentOptions=} getCommentOptions optional function that returns the comment options object.
+ * @returns {ImportPhaseType} import phase
+ */
+
+/**
+ * @param {boolean=} enableImportPhase enable import phase detection
+ * @returns {GetImportPhase} evaluates the import phase for ast node
+ */
+function createGetImportPhase(enableImportPhase) {
+	return (parser, node, getCommentOptions) => {
+		if (!enableImportPhase) return ImportPhase.Evaluation;
+
+		// We now only support `defer import`
+		const phaseBySyntax =
+			"phase" in node && node.phase === "defer"
+				? ImportPhase.Defer
+				: ImportPhase.Evaluation;
+
+		if (!node.range) {
+			return phaseBySyntax;
+		}
+
+		getCommentOptions =
+			getCommentOptions ||
+			(() => {
+				if (!node.range) return null;
+				const { options, errors } = parser.parseCommentOptions(node.range);
+				if (errors) {
+					for (const e of errors) {
+						const { comment } = e;
+						if (!comment.loc) continue;
+
+						const CommentCompilationWarning = getCommentCompilationWarning();
+						parser.state.module.addWarning(
+							new CommentCompilationWarning(
+								`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+								comment.loc
+							)
+						);
+					}
+				}
+				return options;
+			});
+
+		const options = getCommentOptions();
+
+		if (!options || !options.webpackDefer) return phaseBySyntax;
+
+		const { webpackDefer } = options;
+		if (typeof webpackDefer === "boolean") {
+			return webpackDefer ? ImportPhase.Defer : phaseBySyntax;
+		} else if (node.loc) {
+			const CommentCompilationWarning = getCommentCompilationWarning();
+			parser.state.module.addWarning(
+				new CommentCompilationWarning(
+					"webpackDefer magic comment expected a boolean value.",
+					node.loc
+				)
+			);
+		}
+
+		return phaseBySyntax;
+	};
+}
+
+module.exports = {
+	ImportPhase,
+	ImportPhaseUtils,
+	createGetImportPhase
+};

package/lib/dependencies/ImportWeakDependency.js

@@ -16,16 +16,18 @@ const ImportDependency = require("./ImportDependency");
 /** @typedef {import("../javascript/JavascriptParser").ImportAttributes} ImportAttributes */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {ImportDependency.RawReferencedExports} RawReferencedExports */
+/** @typedef {import("./ImportPhase").ImportPhaseType} ImportPhaseType */
 
 class ImportWeakDependency extends ImportDependency {
 	/**
 	 * @param {string} request the request
 	 * @param {Range} range expression range
-	 * @param {RawReferencedExports | null=} referencedExports list of referenced exports
+	 * @param {RawReferencedExports | null} referencedExports list of referenced exports
+	 * @param {ImportPhaseType} phase import phase
 	 * @param {ImportAttributes=} attributes import attributes
 	 */
-	constructor(request, range, referencedExports, attributes) {
-		super(request, range, referencedExports, attributes);
+	constructor(request, range, referencedExports, phase, attributes) {
+		super(request, range, referencedExports, phase, attributes);
 		this.weak = true;
 	}
 
@@ -61,6 +63,7 @@ ImportWeakDependency.Template = class ImportDependencyTemplate extends (
 			strict: /** @type {BuildMeta} */ (module.buildMeta).strictHarmonyModule,
 			message: "import() weak",
 			weak: true,
+			dependency: dep,
 			runtimeRequirements
 		});
 

package/lib/dependencies/LocalModulesHelpers.js

@@ -7,7 +7,7 @@
 
 const LocalModule = require("./LocalModule");
 
-/** @typedef {import("../javascript/JavascriptParser").ParserState} ParserState */
+/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 
 /**
  * @param {string} parent parent module
@@ -34,7 +34,7 @@ const lookup = (parent, mod) => {
 };
 
 /**
- * @param {ParserState} state parser state
+ * @param {JavascriptParserState} state parser state
  * @param {string} name name
  * @returns {LocalModule} local module
  */
@@ -48,7 +48,7 @@ module.exports.addLocalModule = (state, name) => {
 };
 
 /**
- * @param {ParserState} state parser state
+ * @param {JavascriptParserState} state parser state
  * @param {string} name name
  * @param {string=} namedModule named module
  * @returns {LocalModule | null} local module or null