webpack 5.39.0 → 5.41.1

package/lib/ExternalModule.js

@@ -7,6 +7,8 @@
 
 const { OriginalSource, RawSource } = require("webpack-sources");
 const ConcatenationScope = require("./ConcatenationScope");
+const { UsageState } = require("./ExportsInfo");
+const InitFragment = require("./InitFragment");
 const Module = require("./Module");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
@@ -22,6 +24,7 @@ const propertyAccess = require("./util/propertyAccess");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./ExportsInfo")} ExportsInfo */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
@@ -31,16 +34,28 @@ const propertyAccess = require("./util/propertyAccess");
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
  * @typedef {Object} SourceData
  * @property {boolean=} iife
  * @property {string=} init
  * @property {string} expression
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
+ * @property {ReadonlySet<string>=} runtimeRequirements
  */
 
+const TYPES = new Set(["javascript"]);
+const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
+const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([RuntimeGlobals.loadScript]);
+const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
+	RuntimeGlobals.definePropertyGetters
+]);
+const EMPTY_RUNTIME_REQUIREMENTS = new Set([]);
+
 /**
  * @param {string|string[]} variableName the variable name or path
  * @param {string} type the module system
@@ -67,7 +82,7 @@ const getSourceForGlobalVariableExternal = (variableName, type) => {
 const getSourceForCommonJsExternal = moduleAndSpecifiers => {
 	if (!Array.isArray(moduleAndSpecifiers)) {
 		return {
-			expression: `require(${JSON.stringify(moduleAndSpecifiers)});`
+			expression: `require(${JSON.stringify(moduleAndSpecifiers)})`
 		};
 	}
 	const moduleName = moduleAndSpecifiers[0];
@@ -75,7 +90,37 @@ const getSourceForCommonJsExternal = moduleAndSpecifiers => {
 		expression: `require(${JSON.stringify(moduleName)})${propertyAccess(
 			moduleAndSpecifiers,
 			1
-		)};`
+		)}`
+	};
+};
+
+/**
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @returns {SourceData} the generated source
+ */
+const getSourceForCommonJsExternalInNodeModule = moduleAndSpecifiers => {
+	const chunkInitFragments = [
+		new InitFragment(
+			'import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "module";\n',
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			"external module node-commonjs"
+		)
+	];
+	if (!Array.isArray(moduleAndSpecifiers)) {
+		return {
+			expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+				moduleAndSpecifiers
+			)})`,
+			chunkInitFragments
+		};
+	}
+	const moduleName = moduleAndSpecifiers[0];
+	return {
+		expression: `__WEBPACK_EXTERNAL_createRequire(import.meta.url)(${JSON.stringify(
+			moduleName
+		)})${propertyAccess(moduleAndSpecifiers, 1)}`,
+		chunkInitFragments
 	};
 };
 
@@ -112,6 +157,91 @@ const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
 	};
 };
 
+class ModuleExternalInitFragment extends InitFragment {
+	constructor(id, request) {
+		const identifier = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
+			`${id}`
+		)}__`;
+		super(
+			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
+			InitFragment.STAGE_HARMONY_IMPORTS,
+			0,
+			`external module import ${id}`
+		);
+		this._identifier = identifier;
+	}
+
+	getNamespaceIdentifier() {
+		return this._identifier;
+	}
+}
+
+const generateModuleRemapping = (input, exportsInfo, runtime) => {
+	if (exportsInfo.otherExportsInfo.getUsed(runtime) === UsageState.Unused) {
+		const properties = [];
+		for (const exportInfo of exportsInfo.orderedExports) {
+			const used = exportInfo.getUsedName(exportInfo.name, runtime);
+			if (!used) continue;
+			const nestedInfo = exportInfo.getNestedExportsInfo();
+			if (nestedInfo) {
+				const nestedExpr = generateModuleRemapping(
+					`${input}${propertyAccess([exportInfo.name])}`,
+					nestedInfo
+				);
+				if (nestedExpr) {
+					properties.push(`[${JSON.stringify(used)}]: y(${nestedExpr})`);
+					continue;
+				}
+			}
+			properties.push(
+				`[${JSON.stringify(used)}]: () => ${input}${propertyAccess([
+					exportInfo.name
+				])}`
+			);
+		}
+		return `x({ ${properties.join(", ")} })`;
+	}
+};
+
+/**
+ * @param {string|number} id the module id
+ * @param {string|string[]} moduleAndSpecifiers the module request
+ * @param {ExportsInfo} exportsInfo exports info of this module
+ * @param {RuntimeSpec} runtime the runtime
+ * @returns {SourceData} the generated source
+ */
+const getSourceForModuleExternal = (
+	id,
+	moduleAndSpecifiers,
+	exportsInfo,
+	runtime
+) => {
+	if (!Array.isArray(moduleAndSpecifiers))
+		moduleAndSpecifiers = [moduleAndSpecifiers];
+	const initFragment = new ModuleExternalInitFragment(
+		id,
+		moduleAndSpecifiers[0]
+	);
+	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
+		moduleAndSpecifiers,
+		1
+	)}`;
+	const moduleRemapping = generateModuleRemapping(
+		baseAccess,
+		exportsInfo,
+		runtime
+	);
+	let expression = moduleRemapping || baseAccess;
+	return {
+		expression,
+		init: `var x = y => { var x = {}; ${RuntimeGlobals.definePropertyGetters}(x, y); return x; }\nvar y = x => () => x`,
+		runtimeRequirements: moduleRemapping
+			? RUNTIME_REQUIREMENTS_FOR_MODULE
+			: undefined,
+		chunkInitFragments: [initFragment]
+	};
+};
+
 /**
  * @param {string|string[]} urlAndGlobal the script request
  * @param {RuntimeTemplate} runtimeTemplate the runtime template
@@ -144,7 +274,8 @@ const getSourceForScriptExternal = (urlAndGlobal, runtimeTemplate) => {
 			]
 		)}).then(${runtimeTemplate.returningFunction(
 			`${globalName}${propertyAccess(urlAndGlobal, 2)}`
-		)})`
+		)})`,
+		runtimeRequirements: RUNTIME_REQUIREMENTS_FOR_SCRIPT
 	};
 };
 
@@ -210,14 +341,6 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
 	};
 };
 
-const TYPES = new Set(["javascript"]);
-const RUNTIME_REQUIREMENTS = new Set([RuntimeGlobals.module]);
-const RUNTIME_REQUIREMENTS_FOR_SCRIPT = new Set([
-	RuntimeGlobals.module,
-	RuntimeGlobals.loadScript
-]);
-const RUNTIME_REQUIREMENTS_CONCATENATED = new Set([]);
-
 class ExternalModule extends Module {
 	constructor(request, type, userRequest) {
 		super("javascript/dynamic", null);
@@ -293,32 +416,44 @@ class ExternalModule extends Module {
 			exportsType: undefined
 		};
 		this.buildInfo = {
-			strict: this.externalType !== "this",
-			topLevelDeclarations: new Set()
+			strict: true,
+			topLevelDeclarations: new Set(),
+			module: compilation.outputOptions.module
 		};
+		const { request, externalType } = this._getRequestAndExternalType();
 		this.buildMeta.exportsType = "dynamic";
 		let canMangle = false;
 		this.clearDependenciesAndBlocks();
-		switch (this.externalType) {
+		switch (externalType) {
+			case "this":
+				this.buildInfo.strict = false;
+				break;
 			case "system":
-				if (!Array.isArray(this.request) || this.request.length === 1) {
-					this.buildMeta.exportsType = "namespace";
-					canMangle = true;
+			case "module":
+				if (this.buildInfo.module) {
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = true;
+					}
+				} else {
+					this.buildMeta.async = true;
+					if (!Array.isArray(request) || request.length === 1) {
+						this.buildMeta.exportsType = "namespace";
+						canMangle = false;
+					}
 				}
 				break;
+			case "script":
 			case "promise":
 				this.buildMeta.async = true;
 				break;
 			case "import":
 				this.buildMeta.async = true;
-				if (!Array.isArray(this.request) || this.request.length === 1) {
+				if (!Array.isArray(request) || request.length === 1) {
 					this.buildMeta.exportsType = "namespace";
 					canMangle = false;
 				}
 				break;
-			case "script":
-				this.buildMeta.async = true;
-				break;
 		}
 		this.addDependency(new StaticExportsDependency(true, canMangle));
 		callback();
@@ -341,12 +476,16 @@ class ExternalModule extends Module {
 		return undefined;
 	}
 
-	getSourceData(runtimeTemplate, moduleGraph, chunkGraph) {
-		const request =
-			typeof this.request === "object" && !Array.isArray(this.request)
-				? this.request[this.externalType]
-				: this.request;
-		switch (this.externalType) {
+	_getRequestAndExternalType() {
+		let { request, externalType } = this;
+		if (typeof request === "object" && !Array.isArray(request))
+			request = request[externalType];
+		return { request, externalType };
+	}
+
+	_getSourceData(runtimeTemplate, moduleGraph, chunkGraph, runtime) {
+		const { request, externalType } = this._getRequestAndExternalType();
+		switch (externalType) {
 			case "this":
 			case "window":
 			case "self":
@@ -360,6 +499,10 @@ class ExternalModule extends Module {
 			case "commonjs2":
 			case "commonjs-module":
 				return getSourceForCommonJsExternal(request);
+			case "node-commonjs":
+				return this.buildInfo.module
+					? getSourceForCommonJsExternalInNodeModule(request)
+					: getSourceForCommonJsExternal(request);
 			case "amd":
 			case "amd-require":
 			case "umd":
@@ -377,12 +520,28 @@ class ExternalModule extends Module {
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
 			case "module":
+				if (!this.buildInfo.module) {
+					if (!runtimeTemplate.supportsDynamicImport()) {
+						throw new Error(
+							"The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script" +
+								(runtimeTemplate.supportsEcmaScriptModuleSyntax()
+									? "\nDid you mean to build a EcmaScript Module ('output.module: true')?"
+									: "")
+						);
+					}
+					return getSourceForImportExternal(request, runtimeTemplate);
+				}
 				if (!runtimeTemplate.supportsEcmaScriptModuleSyntax()) {
 					throw new Error(
 						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
 					);
 				}
-				throw new Error("Module external type is not implemented yet");
+				return getSourceForModuleExternal(
+					chunkGraph.getModuleId(this),
+					request,
+					moduleGraph.getExportsInfo(this),
+					runtime
+				);
 			case "var":
 			case "promise":
 			case "const":
@@ -405,12 +564,14 @@ class ExternalModule extends Module {
 		runtimeTemplate,
 		moduleGraph,
 		chunkGraph,
+		runtime,
 		concatenationScope
 	}) {
-		const sourceData = this.getSourceData(
+		const sourceData = this._getSourceData(
 			runtimeTemplate,
 			moduleGraph,
-			chunkGraph
+			chunkGraph,
+			runtime
 		);
 
 		let sourceString = sourceData.expression;
@@ -428,6 +589,12 @@ class ExternalModule extends Module {
 		}
 		if (sourceData.init) sourceString = `${sourceData.init}\n${sourceString}`;
 
+		let data = undefined;
+		if (sourceData.chunkInitFragments) {
+			data = new Map();
+			data.set("chunkInitFragments", sourceData.chunkInitFragments);
+		}
+
 		const sources = new Map();
 		if (this.useSourceMap || this.useSimpleSourceMap) {
 			sources.set(
@@ -438,13 +605,21 @@ class ExternalModule extends Module {
 			sources.set("javascript", new RawSource(sourceString));
 		}
 
+		let runtimeRequirements = sourceData.runtimeRequirements;
+		if (!concatenationScope) {
+			if (!runtimeRequirements) {
+				runtimeRequirements = RUNTIME_REQUIREMENTS;
+			} else {
+				const set = new Set(runtimeRequirements);
+				set.add(RuntimeGlobals.module);
+				runtimeRequirements = set;
+			}
+		}
+
 		return {
 			sources,
-			runtimeRequirements: concatenationScope
-				? RUNTIME_REQUIREMENTS_CONCATENATED
-				: this.externalType === "script"
-				? RUNTIME_REQUIREMENTS_FOR_SCRIPT
-				: RUNTIME_REQUIREMENTS
+			runtimeRequirements: runtimeRequirements || EMPTY_RUNTIME_REQUIREMENTS,
+			data
 		};
 	}
 

package/lib/ExternalModuleFactoryPlugin.js

@@ -172,13 +172,14 @@ class ExternalModuleFactoryPlugin {
 								cb
 							);
 						} else {
+							const dependencyType = dependency.category || "";
 							const promise = externals(
 								{
 									context,
 									request: dependency.request,
+									dependencyType,
 									contextInfo,
 									getResolve: options => (context, request, callback) => {
-										const dependencyType = dependency.category || "";
 										const resolveContext = {
 											fileDependencies: data.fileDependencies,
 											missingDependencies: data.missingDependencies,

package/lib/InitFragment.js

@@ -30,6 +30,9 @@ const sortFragmentWithIndex = ([a, i], [b, j]) => {
 	return i - j;
 };
 
+/**
+ * @template Context
+ */
 class InitFragment {
 	/**
 	 * @param {string|Source} content the source code that will be included as initialization code
@@ -47,22 +50,22 @@ class InitFragment {
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
-	getContent(generateContext) {
+	getContent(context) {
 		return this.content;
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
-	getEndContent(generateContext) {
+	getEndContent(context) {
 		return this.endContent;
 	}
 
-	static addToSource(source, initFragments, generateContext) {
+	static addToSource(source, initFragments, context) {
 		if (initFragments.length > 0) {
 			// Sort fragments by position. If 2 fragments have the same position,
 			// use their index.
@@ -104,8 +107,8 @@ class InitFragment {
 				if (Array.isArray(fragment)) {
 					fragment = fragment[0].mergeAll(fragment);
 				}
-				concatSource.add(fragment.getContent(generateContext));
-				const endContent = fragment.getEndContent(generateContext);
+				concatSource.add(fragment.getContent(context));
+				const endContent = fragment.getEndContent(context);
 				if (endContent) {
 					endContents.push(endContent);
 				}

package/lib/MainTemplate.js

@@ -20,7 +20,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Module")} Module} */
 /** @typedef {import("./util/Hash")} Hash} */
 /** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
-/** @typedef {import("./ModuleTemplate").RenderContext} RenderContext} */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext} */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
 /** @typedef {import("./ModuleGraph")} ModuleGraph} */
 /** @typedef {import("./ChunkGraph")} ChunkGraph} */

package/lib/ModuleTemplate.js

@@ -22,15 +22,6 @@ const getJavascriptModulesPlugin = memoize(() =>
 	require("./javascript/JavascriptModulesPlugin")
 );
 
-/**
- * @typedef {Object} RenderContext
- * @property {Chunk} chunk the chunk
- * @property {DependencyTemplates} dependencyTemplates the dependency templates
- * @property {RuntimeTemplate} runtimeTemplate the runtime template
- * @property {ModuleGraph} moduleGraph the module graph
- * @property {ChunkGraph} chunkGraph the chunk graph
- */
-
 // TODO webpack 6: remove this class
 class ModuleTemplate {
 	/**

package/lib/RuntimeTemplate.js

@@ -133,6 +133,14 @@ class RuntimeTemplate {
 			  );
 	}
 
+	destructureObject(items, value) {
+		return this.supportsDestructuring()
+			? `var {${items.join(", ")}} = ${value};`
+			: Template.asString(
+					items.map(item => `var ${item} = ${value}${propertyAccess([item])};`)
+			  );
+	}
+
 	iife(args, body) {
 		return `(${this.basicFunction(args, body)})()`;
 	}

package/lib/Template.js

@@ -18,9 +18,10 @@ const { ConcatSource, PrefixSource } = require("webpack-sources");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("./ModuleTemplate").RenderContext} RenderContext */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 
 const START_LOWERCASE_ALPHABET_CODE = "a".charCodeAt(0);
 const START_UPPERCASE_ALPHABET_CODE = "A".charCodeAt(0);
@@ -283,7 +284,7 @@ class Template {
 	}
 
 	/**
-	 * @param {RenderContext} renderContext render context
+	 * @param {ChunkRenderContext} renderContext render context
 	 * @param {Module[]} modules modules to render (should be ordered by identifier)
 	 * @param {function(Module): Source} renderModule function to render a module
 	 * @param {string=} prefix applying prefix strings

package/lib/TemplatedPathPlugin.js

@@ -116,32 +116,30 @@ const replacePathVariables = (path, data, assetInfo) => {
 	// [path] - /some/path/
 	// [name] - file
 	// [ext] - .js
-	if (data.filename) {
-		if (typeof data.filename === "string") {
-			const { path: file, query, fragment } = parseResource(data.filename);
-
-			const ext = extname(file);
-			const base = basename(file);
-			const name = base.slice(0, base.length - ext.length);
-			const path = file.slice(0, file.length - base.length);
-
-			replacements.set("file", replacer(file));
-			replacements.set("query", replacer(query, true));
-			replacements.set("fragment", replacer(fragment, true));
-			replacements.set("path", replacer(path, true));
-			replacements.set("base", replacer(base));
-			replacements.set("name", replacer(name));
-			replacements.set("ext", replacer(ext, true));
-			// Legacy
-			replacements.set(
-				"filebase",
-				deprecated(
-					replacer(base),
-					"[filebase] is now [base]",
-					"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
-				)
-			);
-		}
+	if (typeof data.filename === "string") {
+		const { path: file, query, fragment } = parseResource(data.filename);
+
+		const ext = extname(file);
+		const base = basename(file);
+		const name = base.slice(0, base.length - ext.length);
+		const path = file.slice(0, file.length - base.length);
+
+		replacements.set("file", replacer(file));
+		replacements.set("query", replacer(query, true));
+		replacements.set("fragment", replacer(fragment, true));
+		replacements.set("path", replacer(path, true));
+		replacements.set("base", replacer(base));
+		replacements.set("name", replacer(name));
+		replacements.set("ext", replacer(ext, true));
+		// Legacy
+		replacements.set(
+			"filebase",
+			deprecated(
+				replacer(base),
+				"[filebase] is now [base]",
+				"DEP_WEBPACK_TEMPLATE_PATH_PLUGIN_REPLACE_PATH_VARIABLES_FILENAME"
+			)
+		);
 	}
 
 	// Compilation context

package/lib/Watching.js

@@ -86,7 +86,7 @@ class Watching {
 
 	_go(fileTimeInfoEntries, contextTimeInfoEntries, changedFiles, removedFiles) {
 		this._initial = false;
-		this.startTime = Date.now();
+		if (this.startTime === null) this.startTime = Date.now();
 		this.running = true;
 		if (this.watcher) {
 			this.pausedWatcher = this.watcher;
@@ -252,6 +252,7 @@ class Watching {
 			compilation.endTime = Date.now();
 			stats = new Stats(compilation);
 		}
+		this.startTime = null;
 		if (err) return handleError(err);
 
 		const cbs = this.callbacks;

package/lib/WebpackOptionsApply.js

@@ -113,7 +113,7 @@ class WebpackOptionsApply extends OptionsApply {
 		if (options.externalsPresets.nwjs) {
 			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 			const ExternalsPlugin = require("./ExternalsPlugin");
-			new ExternalsPlugin("commonjs", "nw.gui").apply(compiler);
+			new ExternalsPlugin("node-commonjs", "nw.gui").apply(compiler);
 		}
 		if (options.externalsPresets.webAsync) {
 			//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
@@ -139,10 +139,11 @@ class WebpackOptionsApply extends OptionsApply {
 					new CommonJsChunkFormatPlugin().apply(compiler);
 					break;
 				}
-				case "module":
-					throw new Error(
-						"EcmaScript Module Chunk Format is not implemented yet"
-					);
+				case "module": {
+					const ModuleChunkFormatPlugin = require("./esm/ModuleChunkFormatPlugin");
+					new ModuleChunkFormatPlugin().apply(compiler);
+					break;
+				}
 				default:
 					throw new Error(
 						"Unsupported chunk format '" + options.output.chunkFormat + "'."
@@ -317,7 +318,8 @@ class WebpackOptionsApply extends OptionsApply {
 		new URLPlugin().apply(compiler);
 		new WorkerPlugin(
 			options.output.workerChunkLoading,
-			options.output.workerWasmLoading
+			options.output.workerWasmLoading,
+			options.output.module
 		).apply(compiler);
 
 		new DefaultStatsFactoryPlugin().apply(compiler);
@@ -573,7 +575,8 @@ class WebpackOptionsApply extends OptionsApply {
 									allowCollectingMemory: cacheOptions.allowCollectingMemory
 								}),
 								cacheOptions.idleTimeout,
-								cacheOptions.idleTimeoutForInitialStore
+								cacheOptions.idleTimeoutForInitialStore,
+								cacheOptions.idleTimeoutAfterLargeChanges
 							).apply(compiler);
 							break;
 						}

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -12,6 +12,9 @@ const Template = require("../Template");
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 
+/**
+ * @typedef {GenerateContext} Context
+ */
 class AwaitDependenciesInitFragment extends InitFragment {
 	/**
 	 * @param {Set<string>} promises the promises that should be awaited
@@ -35,7 +38,7 @@ class AwaitDependenciesInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {GenerateContext} generateContext context for generate
+	 * @param {Context} context context
 	 * @returns {string|Source} the source code that will be included as initialization code
 	 */
 	getContent({ runtimeRequirements }) {