webpack 5.102.1 → 5.104.0

package/lib/dependencies/CssIcssImportDependency.js

@@ -5,40 +5,117 @@
 
 "use strict";
 
+const WebpackError = require("../WebpackError");
+const { cssExportConvention } = require("../util/conventions");
 const makeSerializable = require("../util/makeSerializable");
-const CssIcssExportDependency = require("./CssIcssExportDependency");
-const CssLocalIdentifierDependency = require("./CssLocalIdentifierDependency");
-const ModuleDependency = require("./ModuleDependency");
+const memoize = require("../util/memoize");
+const CssImportDependency = require("./CssImportDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../CssModule")} CssModule */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+/** @typedef {import("./CssIcssExportDependency").ExportMode} ExportMode */
+/** @typedef {import("./CssIcssExportDependency").ExportType} ExportType */
 
-class CssIcssImportDependency extends ModuleDependency {
+const getCssIcssExportDependency = memoize(() =>
+	require("./CssIcssExportDependency")
+);
+
+class CssIcssImportDependency extends CssImportDependency {
 	/**
 	 * Example of dependency:
 	 *
-	 *:import('./style.css') { IMPORTED_NAME: v-primary }
+	 * :import('./style.css') { value: name }
 	 * @param {string} request request request path which needs resolving
-	 * @param {string} exportName export name
 	 * @param {Range} range the range of dependency
+	 * @param {"local" | "global"} mode mode of the parsed CSS
+	 * @param {string} name name
+	 * @param {string=} exportName export value
+	 * @param {ExportMode=} exportMode export mode
+	 * @param {ExportType=} exportType export type
 	 */
-	constructor(request, exportName, range) {
-		super(request);
-		this.exportName = exportName;
-		this.range = range;
+	constructor(
+		request,
+		range,
+		mode,
+		name,
+		exportName = undefined,
+		exportMode = getCssIcssExportDependency().EXPORT_MODE.NONE,
+		exportType = getCssIcssExportDependency().EXPORT_TYPE.NORMAL
+	) {
+		super(request, range, mode);
+		this.name = name;
+		this.value = exportName;
+		this.interpolate = true;
+		this.exportMode = exportMode;
+		this.exportType = exportType;
 	}
 
 	get type() {
 		return "css :import";
 	}
 
-	get category() {
-		return "css-import";
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return `${super.getResourceIdentifier()}|mode${this.mode}|name${this.name}`;
+	}
+
+	/**
+	 * @param {string} name export name
+	 * @param {CssGeneratorExportsConvention} convention convention of the export name
+	 * @returns {string[]} convention results
+	 */
+	getExportsConventionNames(name, convention) {
+		return cssExportConvention(name, convention);
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return [
+			{
+				name: [this.name],
+				canMangle: true
+			}
+		];
+	}
+
+	/**
+	 * Returns warnings
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		const module = moduleGraph.getModule(this);
+
+		if (
+			module &&
+			!moduleGraph.getExportsInfo(module).isExportProvided(this.name)
+		) {
+			const error = new WebpackError(
+				`Referenced name "${this.name}" in "${this.userRequest}" not found`
+			);
+			error.module = module;
+
+			return [error];
+		}
+
+		return null;
 	}
 
 	/**
@@ -46,8 +123,11 @@ class CssIcssImportDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		const { write } = context;
-		write(this.range);
-		write(this.exportName);
+		write(this.name);
+		write(this.value);
+		write(this.interpolate);
+		write(this.exportMode);
+		write(this.exportType);
 		super.serialize(context);
 	}
 
@@ -56,14 +136,17 @@ class CssIcssImportDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		const { read } = context;
-		this.range = read();
-		this.exportName = read();
+		this.name = read();
+		this.value = read();
+		this.interpolate = read();
+		this.exportMode = read();
+		this.exportType = read();
 		super.deserialize(context);
 	}
 }
 
 CssIcssImportDependency.Template = class CssIcssImportDependencyTemplate extends (
-	ModuleDependency.Template
+	CssImportDependency.Template
 ) {
 	/**
 	 * @param {Dependency} dependency the dependency for which the template should be applied
@@ -73,42 +156,22 @@ CssIcssImportDependency.Template = class CssIcssImportDependencyTemplate extends
 	 */
 	apply(dependency, source, templateContext) {
 		const dep = /** @type {CssIcssImportDependency} */ (dependency);
-		const { range } = dep;
-		const module =
-			/** @type {Module} */
-			(templateContext.moduleGraph.getModule(dep));
-		let value;
-
-		for (const item of module.dependencies) {
-			if (
-				item instanceof CssLocalIdentifierDependency &&
-				dep.exportName === item.name
-			) {
-				value = CssLocalIdentifierDependency.Template.getIdentifier(
-					item,
-					dep.exportName,
-					{
-						...templateContext,
-						module
-					}
-				);
-				break;
-			} else if (
-				item instanceof CssIcssExportDependency &&
-				dep.exportName === item.name
-			) {
-				value = item.value;
-				break;
-			}
-		}
 
-		if (!value) {
-			throw new Error(
-				`Imported '${dep.exportName}' name from '${dep.request}' not found`
-			);
+		if (dep.value) {
+			const { moduleGraph } = templateContext;
+			const module =
+				/** @type {CssModule} */
+				(moduleGraph.getModule(dep));
+			const CssIcssExportDependency = getCssIcssExportDependency();
+			const template = new CssIcssExportDependency.Template();
+			const originalName = dep.name;
+			const originalExportName = dep.value;
+			dep.value = originalName;
+			dep.name = originalExportName;
+			template.apply(dep, source, { ...templateContext, module });
+			dep.name = originalName;
+			dep.value = originalExportName;
 		}
-
-		source.replace(range[0], range[1], value);
 	}
 };
 

package/lib/dependencies/CssIcssSymbolDependency.js

@@ -5,7 +5,9 @@
 
 "use strict";
 
+const { CSS_TYPE } = require("../ModuleSourceTypeConstants");
 const makeSerializable = require("../util/makeSerializable");
+const CssIcssExportDependency = require("./CssIcssExportDependency");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -24,23 +26,21 @@ const NullDependency = require("./NullDependency");
 class CssIcssSymbolDependency extends NullDependency {
 	/**
 	 * @param {string} name name
-	 * @param {string} value value
+	 * @param {string} symbol symbol
 	 * @param {Range} range range
+	 * @param {boolean=} isReference true when is reference, otherwise false
 	 */
-	constructor(name, value, range) {
+	constructor(name, symbol, range, isReference) {
 		super();
 		this.name = name;
-		this.value = value;
+		this.symbol = symbol;
 		this.range = range;
+		this.isReference = isReference;
 		this._hashUpdate = undefined;
 	}
 
 	get type() {
-		return "css @value identifier";
-	}
-
-	get category() {
-		return "self";
+		return "css symbol identifier";
 	}
 
 	/**
@@ -56,23 +56,6 @@ class CssIcssSymbolDependency extends NullDependency {
 		hash.update(this._hashUpdate);
 	}
 
-	/**
-	 * Returns the exported names
-	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {ExportsSpec | undefined} export names
-	 */
-	getExports(moduleGraph) {
-		return {
-			exports: [
-				{
-					name: this.name,
-					canMangle: true
-				}
-			],
-			dependencies: undefined
-		};
-	}
-
 	/**
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
@@ -80,7 +63,7 @@ class CssIcssSymbolDependency extends NullDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		return [[this.name]];
+		return [[this.symbol]];
 	}
 
 	/**
@@ -89,8 +72,10 @@ class CssIcssSymbolDependency extends NullDependency {
 	serialize(context) {
 		const { write } = context;
 		write(this.name);
+		write(this.symbol);
 		write(this.value);
 		write(this.range);
+		write(this.isReference);
 		super.serialize(context);
 	}
 
@@ -100,13 +85,15 @@ class CssIcssSymbolDependency extends NullDependency {
 	deserialize(context) {
 		const { read } = context;
 		this.name = read();
+		this.symbol = read();
 		this.value = read();
 		this.range = read();
+		this.isReference = read();
 		super.deserialize(context);
 	}
 }
 
-CssIcssSymbolDependency.Template = class CssValueAtRuleDependencyTemplate extends (
+CssIcssSymbolDependency.Template = class CssIcssSymbolDependencyTemplate extends (
 	NullDependency.Template
 ) {
 	/**
@@ -115,12 +102,23 @@ CssIcssSymbolDependency.Template = class CssValueAtRuleDependencyTemplate extend
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { cssData }) {
-		const dep = /** @type {CssIcssSymbolDependency} */ (dependency);
-
-		source.replace(dep.range[0], dep.range[1] - 1, dep.value);
-
-		cssData.exports.set(dep.name, dep.value);
+	apply(dependency, source, templateContext) {
+		if (templateContext.type === CSS_TYPE) {
+			const dep = /** @type {CssIcssSymbolDependency} */ (dependency);
+			/** @type {string | undefined} */
+			const value = dep.isReference
+				? CssIcssExportDependency.Template.findReference(
+						dep.symbol,
+						templateContext
+					)
+				: dep.symbol;
+
+			if (!value) {
+				return;
+			}
+
+			source.replace(dep.range[0], dep.range[1] - 1, value);
+		}
 	}
 };
 

package/lib/dependencies/CssImportDependency.js

@@ -10,7 +10,7 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../css/CssParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
@@ -21,13 +21,15 @@ class CssImportDependency extends ModuleDependency {
 	 * \@import url("landscape.css") layer(forms) screen and (orientation: landscape) screen and (orientation: landscape);
 	 * @param {string} request request
 	 * @param {Range} range range of the argument
-	 * @param {string | undefined} layer layer
-	 * @param {string | undefined} supports list of supports conditions
-	 * @param {string | undefined} media list of media conditions
+	 * @param {"local" | "global"=} mode mode of the parsed CSS
+	 * @param {string=} layer layer
+	 * @param {string=} supports list of supports conditions
+	 * @param {string=} media list of media conditions
 	 */
-	constructor(request, range, layer, supports, media) {
+	constructor(request, range, mode, layer, supports, media) {
 		super(request);
 		this.range = range;
+		this.mode = mode;
 		this.layer = layer;
 		this.supports = supports;
 		this.media = media;
@@ -38,7 +40,7 @@ class CssImportDependency extends ModuleDependency {
 	}
 
 	get category() {
-		return "css-import";
+		return `css-import${this.mode ? `-${this.mode}-module` : ""}`;
 	}
 
 	/**
@@ -47,6 +49,10 @@ class CssImportDependency extends ModuleDependency {
 	getResourceIdentifier() {
 		let str = `context${this._context || ""}|module${this.request}`;
 
+		if (this.mode) {
+			str += `|mode${this.mode}`;
+		}
+
 		if (this.layer) {
 			str += `|layer${this.layer}`;
 		}
@@ -67,6 +73,8 @@ class CssImportDependency extends ModuleDependency {
 	 */
 	serialize(context) {
 		const { write } = context;
+		write(this.range);
+		write(this.mode);
 		write(this.layer);
 		write(this.supports);
 		write(this.media);
@@ -78,6 +86,8 @@ class CssImportDependency extends ModuleDependency {
 	 */
 	deserialize(context) {
 		const { read } = context;
+		this.range = read();
+		this.mode = read();
 		this.layer = read();
 		this.supports = read();
 		this.media = read();
@@ -95,6 +105,7 @@ CssImportDependency.Template = class CssImportDependencyTemplate extends (
 	 * @returns {void}
 	 */
 	apply(dependency, source, templateContext) {
+		if (templateContext.type === "javascript") return;
 		const dep = /** @type {CssImportDependency} */ (dependency);
 
 		source.replace(dep.range[0], dep.range[1] - 1, "");

package/lib/dependencies/CssUrlDependency.js

@@ -13,7 +13,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 /** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
@@ -118,8 +118,9 @@ CssUrlDependency.Template = class CssUrlDependencyTemplate extends (
 	apply(
 		dependency,
 		source,
-		{ moduleGraph, runtimeTemplate, codeGenerationResults }
+		{ type, moduleGraph, runtimeTemplate, codeGenerationResults }
 	) {
+		if (type === "javascript") return;
 		const dep = /** @type {CssUrlDependency} */ (dependency);
 		const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 

package/lib/dependencies/DynamicExports.js

@@ -6,13 +6,13 @@
 "use strict";
 
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 
-/** @type {WeakMap<ParserState, boolean>} */
+/** @type {WeakMap<JavascriptParserState, boolean>} */
 const parserStateExportsState = new WeakMap();
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {JavascriptParserState} parserState parser state
  * @returns {void}
  */
 module.exports.bailout = (parserState) => {
@@ -26,7 +26,7 @@ module.exports.bailout = (parserState) => {
 };
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {JavascriptParserState} parserState parser state
  * @returns {void}
  */
 module.exports.enable = (parserState) => {
@@ -41,7 +41,7 @@ module.exports.enable = (parserState) => {
 };
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {JavascriptParserState} parserState parser state
  * @returns {boolean} true, when enabled
  */
 module.exports.isEnabled = (parserState) => {
@@ -50,7 +50,7 @@ module.exports.isEnabled = (parserState) => {
 };
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {JavascriptParserState} parserState parser state
  * @returns {void}
  */
 module.exports.setDynamic = (parserState) => {
@@ -61,7 +61,7 @@ module.exports.setDynamic = (parserState) => {
 };
 
 /**
- * @param {ParserState} parserState parser state
+ * @param {JavascriptParserState} parserState parser state
  * @returns {void}
  */
 module.exports.setFlagged = (parserState) => {

package/lib/dependencies/ExternalModuleDependency.js

@@ -13,17 +13,19 @@ const ExternalModuleInitFragment = require("./ExternalModuleInitFragment");
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../dependencies/ExternalModuleInitFragment").ArrayImportSpecifiers} ArrayImportSpecifiers */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class ExternalModuleDependency extends CachedConstDependency {
 	/**
 	 * @param {string} module module
-	 * @param {{ name: string, value: string }[]} importSpecifiers import specifiers
+	 * @param {ArrayImportSpecifiers} importSpecifiers import specifiers
 	 * @param {string | undefined} defaultImport default import
 	 * @param {string} expression expression
-	 * @param {Range} range range
+	 * @param {Range | null} range range
 	 * @param {string} identifier identifier
+	 * @param {number=} place place where we inject the expression
 	 */
 	constructor(
 		module,
@@ -31,9 +33,10 @@ class ExternalModuleDependency extends CachedConstDependency {
 		defaultImport,
 		expression,
 		range,
-		identifier
+		identifier,
+		place = CachedConstDependency.PLACE_MODULE
 	) {
-		super(expression, range, identifier);
+		super(expression, range, identifier, place);
 
 		this.importedModule = module;
 		this.specifiers = importSpecifiers;

package/lib/dependencies/ExternalModuleInitFragment.js

@@ -12,6 +12,7 @@ const makeSerializable = require("../util/makeSerializable");
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {{ name: string, value?: string }[]} ArrayImportSpecifiers */
 /** @typedef {Map<string, Set<string>>} ImportSpecifiers */
 
 /**
@@ -20,7 +21,7 @@ const makeSerializable = require("../util/makeSerializable");
 class ExternalModuleInitFragment extends InitFragment {
 	/**
 	 * @param {string} importedModule imported module
-	 * @param {{ name: string, value?: string }[] | ImportSpecifiers} specifiers import specifiers
+	 * @param {ArrayImportSpecifiers | ImportSpecifiers} specifiers import specifiers
 	 * @param {string=} defaultImport default import
 	 */
 	constructor(importedModule, specifiers, defaultImport) {
@@ -99,7 +100,7 @@ class ExternalModuleInitFragment extends InitFragment {
 
 		return `import ${importsString} from ${JSON.stringify(
 			this.importedModule
-		)};`;
+		)};\n`;
 	}
 
 	/**

package/lib/dependencies/ExternalModuleInitFragmentDependency.js

@@ -0,0 +1,96 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const DependencyTemplate = require("../DependencyTemplate");
+const makeSerializable = require("../util/makeSerializable");
+const ExternalModuleInitFragment = require("./ExternalModuleInitFragment");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../dependencies/ExternalModuleInitFragment").ArrayImportSpecifiers} ArrayImportSpecifiers */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+class ExternalModuleInitFragmentDependency extends NullDependency {
+	/**
+	 * @param {string} module module
+	 * @param {ArrayImportSpecifiers} importSpecifiers import specifiers
+	 * @param {string | undefined} defaultImport default import
+	 */
+	constructor(module, importSpecifiers, defaultImport) {
+		super();
+		this.importedModule = module;
+		this.specifiers = importSpecifiers;
+		this.default = defaultImport;
+	}
+
+	/**
+	 * @returns {string} hash update
+	 */
+	_createHashUpdate() {
+		return `${this.importedModule}${JSON.stringify(this.specifiers)}${
+			this.default || "null"
+		}`;
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.importedModule);
+		write(this.specifiers);
+		write(this.default);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.importedModule = read();
+		this.specifiers = read();
+		this.default = read();
+	}
+}
+
+makeSerializable(
+	ExternalModuleInitFragmentDependency,
+	"webpack/lib/dependencies/ExternalModuleConstDependency"
+);
+
+ExternalModuleInitFragmentDependency.Template = class ExternalModuleConstDependencyTemplate extends (
+	DependencyTemplate
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep =
+			/** @type {ExternalModuleInitFragmentDependency} */
+			(dependency);
+		const { chunkInitFragments, runtimeTemplate } = templateContext;
+
+		chunkInitFragments.push(
+			new ExternalModuleInitFragment(
+				`${runtimeTemplate.supportNodePrefixForCoreModules() ? "node:" : ""}${
+					dep.importedModule
+				}`,
+				dep.specifiers,
+				dep.default
+			)
+		);
+	}
+};
+
+module.exports = ExternalModuleInitFragmentDependency;

package/lib/dependencies/HarmonyAcceptDependency.js

@@ -9,6 +9,7 @@ const Template = require("../Template");
 const AwaitDependenciesInitFragment = require("../async-modules/AwaitDependenciesInitFragment");
 const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
+const { ImportPhaseUtils } = require("./ImportPhase");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -120,7 +121,11 @@ HarmonyAcceptDependency.Template = class HarmonyAcceptDependencyTemplate extends
 			for (const d of module.dependencies) {
 				if (deferDependency && noDeferredDependency) break;
 				if (isRelatedHarmonyImportDependency(dependency, d)) {
-					if (/** @type {HarmonyImportDependency} */ (d).defer) {
+					if (
+						ImportPhaseUtils.isDefer(
+							/** @type {HarmonyImportDependency} */ (d).phase
+						)
+					) {
 						deferDependency = /** @type {HarmonyImportDependency} */ (d);
 					} else {
 						noDeferredDependency = /** @type {HarmonyImportDependency} */ (d);