webpack 5.90.0 → 5.90.2

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -19,13 +19,30 @@ const { getLocalModule } = require("./LocalModulesHelpers");
 const UnsupportedDependency = require("./UnsupportedDependency");
 const getFunctionExpression = require("./getFunctionExpression");
 
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 class AMDRequireDependenciesBlockParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parserOptions
+	 */
 	constructor(options) {
 		this.options = options;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {Expression | SpreadElement} expression expression
+	 * @returns {boolean} need bind this
+	 */
 	processFunctionArgument(parser, expression) {
 		let bindThis = true;
 		const fnData = getFunctionExpression(expression);
@@ -65,9 +82,15 @@ class AMDRequireDependenciesBlockParserPlugin {
 			);
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
 	processArray(parser, expr, param) {
 		if (param.isArray()) {
-			for (const p of param.items) {
+			for (const p of /** @type {BasicEvaluatedExpression[]} */ (param.items)) {
 				const result = this.processItem(parser, expr, p);
 				if (result === undefined) {
 					this.processContext(parser, expr, p);
@@ -75,8 +98,9 @@ class AMDRequireDependenciesBlockParserPlugin {
 			}
 			return true;
 		} else if (param.isConstArray()) {
+			/** @type {(string | LocalModuleDependency | AMDRequireItemDependency)[]} */
 			const deps = [];
-			for (const request of param.array) {
+			for (const request of /** @type {any[]} */ (param.array)) {
 				let dep, localModule;
 				if (request === "require") {
 					dep = RuntimeGlobals.require;
@@ -85,26 +109,38 @@ class AMDRequireDependenciesBlockParserPlugin {
 				} else if ((localModule = getLocalModule(parser.state, request))) {
 					localModule.flagUsed();
 					dep = new LocalModuleDependency(localModule, undefined, false);
-					dep.loc = expr.loc;
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addPresentationalDependency(dep);
 				} else {
 					dep = this.newRequireItemDependency(request);
-					dep.loc = expr.loc;
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					dep.optional = !!parser.scope.inTry;
 					parser.state.current.addDependency(dep);
 				}
 				deps.push(dep);
 			}
-			const dep = this.newRequireArrayDependency(deps, param.range);
-			dep.loc = expr.loc;
+			const dep = this.newRequireArrayDependency(
+				deps,
+				/** @type {Range} */ (param.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			dep.optional = !!parser.scope.inTry;
 			parser.state.module.addPresentationalDependency(dep);
 			return true;
 		}
 	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
 	processItem(parser, expr, param) {
 		if (param.isConditional()) {
-			for (const p of param.options) {
+			for (const p of /** @type {BasicEvaluatedExpression[]} */ (
+				param.options
+			)) {
 				const result = this.processItem(parser, expr, p);
 				if (result === undefined) {
 					this.processContext(parser, expr, p);
@@ -114,40 +150,59 @@ class AMDRequireDependenciesBlockParserPlugin {
 		} else if (param.isString()) {
 			let dep, localModule;
 			if (param.string === "require") {
-				dep = new ConstDependency(RuntimeGlobals.require, param.string, [
-					RuntimeGlobals.require
-				]);
+				dep = new ConstDependency(
+					RuntimeGlobals.require,
+					/** @type {TODO} */ (param.string),
+					[RuntimeGlobals.require]
+				);
 			} else if (param.string === "module") {
 				dep = new ConstDependency(
-					parser.state.module.buildInfo.moduleArgument,
-					param.range,
+					/** @type {BuildInfo} */
+					(parser.state.module.buildInfo).moduleArgument,
+					/** @type {Range} */ (param.range),
 					[RuntimeGlobals.module]
 				);
 			} else if (param.string === "exports") {
 				dep = new ConstDependency(
-					parser.state.module.buildInfo.exportsArgument,
-					param.range,
+					/** @type {BuildInfo} */
+					(parser.state.module.buildInfo).exportsArgument,
+					/** @type {Range} */ (param.range),
 					[RuntimeGlobals.exports]
 				);
-			} else if ((localModule = getLocalModule(parser.state, param.string))) {
+			} else if (
+				(localModule = getLocalModule(
+					parser.state,
+					/** @type {string} */ (param.string)
+				))
+			) {
 				localModule.flagUsed();
 				dep = new LocalModuleDependency(localModule, param.range, false);
 			} else {
-				dep = this.newRequireItemDependency(param.string, param.range);
-				dep.loc = expr.loc;
+				dep = this.newRequireItemDependency(
+					/** @type {string} */ (param.string),
+					param.range
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.optional = !!parser.scope.inTry;
 				parser.state.current.addDependency(dep);
 				return true;
 			}
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			parser.state.module.addPresentationalDependency(dep);
 			return true;
 		}
 	}
+
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {boolean | undefined} result
+	 */
 	processContext(parser, expr, param) {
 		const dep = ContextDependencyHelpers.create(
 			AMDRequireContextDependency,
-			param.range,
+			/** @type {Range} */ (param.range),
 			param,
 			expr,
 			this.options,
@@ -157,38 +212,55 @@ class AMDRequireDependenciesBlockParserPlugin {
 			parser
 		);
 		if (!dep) return;
-		dep.loc = expr.loc;
+		dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 		dep.optional = !!parser.scope.inTry;
 		parser.state.current.addDependency(dep);
 		return true;
 	}
 
+	/**
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {string | undefined} result
+	 */
 	processArrayForRequestString(param) {
 		if (param.isArray()) {
-			const result = param.items.map(item =>
-				this.processItemForRequestString(item)
-			);
+			const result =
+				/** @type {BasicEvaluatedExpression[]} */
+				(param.items).map(item => this.processItemForRequestString(item));
 			if (result.every(Boolean)) return result.join(" ");
 		} else if (param.isConstArray()) {
-			return param.array.join(" ");
+			return /** @type {string[]} */ (param.array).join(" ");
 		}
 	}
 
+	/**
+	 * @param {BasicEvaluatedExpression} param param
+	 * @returns {string | undefined} result
+	 */
 	processItemForRequestString(param) {
 		if (param.isConditional()) {
-			const result = param.options.map(item =>
-				this.processItemForRequestString(item)
-			);
+			const result =
+				/** @type {BasicEvaluatedExpression[]} */
+				(param.options).map(item => this.processItemForRequestString(item));
 			if (result.every(Boolean)) return result.join("|");
 		} else if (param.isString()) {
 			return param.string;
 		}
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @param {CallExpression} expr call expression
+	 * @returns {boolean | undefined} result
+	 */
 	processCallRequire(parser, expr) {
+		/** @type {BasicEvaluatedExpression | undefined} */
 		let param;
+		/** @type {AMDRequireDependenciesBlock | undefined | null} */
 		let depBlock;
+		/** @type {AMDRequireDependency | undefined} */
 		let dep;
+		/** @type {boolean | undefined} */
 		let result;
 
 		const old = parser.state.current;
@@ -196,57 +268,76 @@ class AMDRequireDependenciesBlockParserPlugin {
 		if (expr.arguments.length >= 1) {
 			param = parser.evaluateExpression(expr.arguments[0]);
 			depBlock = this.newRequireDependenciesBlock(
-				expr.loc,
-				this.processArrayForRequestString(param)
+				/** @type {DependencyLocation} */ (expr.loc),
+				/** @type {string} */ (this.processArrayForRequestString(param))
 			);
 			dep = this.newRequireDependency(
-				expr.range,
-				param.range,
-				expr.arguments.length > 1 ? expr.arguments[1].range : null,
-				expr.arguments.length > 2 ? expr.arguments[2].range : null
+				/** @type {Range} */ (expr.range),
+				/** @type {Range} */ (param.range),
+				expr.arguments.length > 1
+					? /** @type {Range} */ (expr.arguments[1].range)
+					: null,
+				expr.arguments.length > 2
+					? /** @type {Range} */ (expr.arguments[2].range)
+					: null
 			);
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			depBlock.addDependency(dep);
 
-			parser.state.current = depBlock;
+			parser.state.current = /** @type {TODO} */ (depBlock);
 		}
 
 		if (expr.arguments.length === 1) {
 			parser.inScope([], () => {
-				result = this.processArray(parser, expr, param);
+				result = this.processArray(
+					parser,
+					expr,
+					/** @type {BasicEvaluatedExpression} */ (param)
+				);
 			});
 			parser.state.current = old;
 			if (!result) return;
-			parser.state.current.addBlock(depBlock);
+			parser.state.current.addBlock(
+				/** @type {AMDRequireDependenciesBlock} */ (depBlock)
+			);
 			return true;
 		}
 
 		if (expr.arguments.length === 2 || expr.arguments.length === 3) {
 			try {
 				parser.inScope([], () => {
-					result = this.processArray(parser, expr, param);
+					result = this.processArray(
+						parser,
+						expr,
+						/** @type {BasicEvaluatedExpression} */ (param)
+					);
 				});
 				if (!result) {
-					const dep = new UnsupportedDependency("unsupported", expr.range);
+					const dep = new UnsupportedDependency(
+						"unsupported",
+						/** @type {Range} */ (expr.range)
+					);
 					old.addPresentationalDependency(dep);
 					if (parser.state.module) {
 						parser.state.module.addError(
 							new UnsupportedFeatureWarning(
 								"Cannot statically analyse 'require(…, …)' in line " +
-									expr.loc.start.line,
-								expr.loc
+									/** @type {SourceLocation} */ (expr.loc).start.line,
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					}
 					depBlock = null;
 					return true;
 				}
-				dep.functionBindThis = this.processFunctionArgument(
+				/** @type {AMDRequireDependency} */
+				(dep).functionBindThis = this.processFunctionArgument(
 					parser,
 					expr.arguments[1]
 				);
 				if (expr.arguments.length === 3) {
-					dep.errorCallbackBindThis = this.processFunctionArgument(
+					/** @type {AMDRequireDependency} */
+					(dep).errorCallbackBindThis = this.processFunctionArgument(
 						parser,
 						expr.arguments[2]
 					);
@@ -259,9 +350,22 @@ class AMDRequireDependenciesBlockParserPlugin {
 		}
 	}
 
+	/**
+	 * @param {DependencyLocation} loc location
+	 * @param {string} request request
+	 * @returns {AMDRequireDependenciesBlock} AMDRequireDependenciesBlock
+	 */
 	newRequireDependenciesBlock(loc, request) {
 		return new AMDRequireDependenciesBlock(loc, request);
 	}
+
+	/**
+	 * @param {Range} outerRange outer range
+	 * @param {Range} arrayRange array range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} errorCallbackRange error callback range
+	 * @returns {AMDRequireDependency} dependency
+	 */
 	newRequireDependency(
 		outerRange,
 		arrayRange,
@@ -275,9 +379,21 @@ class AMDRequireDependenciesBlockParserPlugin {
 			errorCallbackRange
 		);
 	}
+
+	/**
+	 * @param {string} request request
+	 * @param {Range=} range range
+	 * @returns {AMDRequireItemDependency} AMDRequireItemDependency
+	 */
 	newRequireItemDependency(request, range) {
 		return new AMDRequireItemDependency(request, range);
 	}
+
+	/**
+	 * @param {(string | LocalModuleDependency | AMDRequireItemDependency)[]} depsArray deps array
+	 * @param {Range} range range
+	 * @returns {AMDRequireArrayDependency} AMDRequireArrayDependency
+	 */
 	newRequireArrayDependency(depsArray, range) {
 		return new AMDRequireArrayDependency(depsArray, range);
 	}

package/lib/dependencies/AMDRequireDependency.js

@@ -21,8 +21,8 @@ class AMDRequireDependency extends NullDependency {
 	/**
 	 * @param {Range} outerRange outer range
 	 * @param {Range} arrayRange array range
-	 * @param {Range} functionRange function range
-	 * @param {Range} errorCallbackRange error callback range
+	 * @param {Range | null} functionRange function range
+	 * @param {Range | null} errorCallbackRange error callback range
 	 */
 	constructor(outerRange, arrayRange, functionRange, errorCallbackRange) {
 		super();

package/lib/dependencies/AMDRequireItemDependency.js

@@ -14,7 +14,7 @@ const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateA
 class AMDRequireItemDependency extends ModuleDependency {
 	/**
 	 * @param {string} request the request string
-	 * @param {Range} range location in source code
+	 * @param {Range=} range location in source code
 	 */
 	constructor(request, range) {
 		super(request);

package/lib/dependencies/ExportsInfoDependency.js

@@ -25,7 +25,7 @@ const NullDependency = require("./NullDependency");
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {Module} module the module
- * @param {string | null} exportName name of the export if any
+ * @param {string[] | null} exportName name of the export if any
  * @param {string | null} property name of the requested property
  * @param {RuntimeSpec} runtime for which runtime
  * @returns {any} value of the property
@@ -51,23 +51,19 @@ const getProperty = (moduleGraph, module, exportName, property, runtime) => {
 	switch (property) {
 		case "canMangle": {
 			const exportsInfo = moduleGraph.getExportsInfo(module);
-			const exportInfo = exportsInfo.getExportInfo(
-				/** @type {string} */ (exportName)
-			);
+			const exportInfo = exportsInfo.getExportInfo(exportName[0]);
 			if (exportInfo) return exportInfo.canMangle;
 			return exportsInfo.otherExportsInfo.canMangle;
 		}
 		case "used":
 			return (
-				moduleGraph
-					.getExportsInfo(module)
-					.getUsed(/** @type {string} */ (exportName), runtime) !==
+				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==
 				UsageState.Unused
 			);
 		case "useInfo": {
 			const state = moduleGraph
 				.getExportsInfo(module)
-				.getUsed(/** @type {string} */ (exportName), runtime);
+				.getUsed(exportName, runtime);
 			switch (state) {
 				case UsageState.Used:
 				case UsageState.OnlyPropertiesUsed:
@@ -83,9 +79,7 @@ const getProperty = (moduleGraph, module, exportName, property, runtime) => {
 			}
 		}
 		case "provideInfo":
-			return moduleGraph
-				.getExportsInfo(module)
-				.isExportProvided(/** @type {string} */ (exportName));
+			return moduleGraph.getExportsInfo(module).isExportProvided(exportName);
 	}
 	return undefined;
 };
@@ -93,7 +87,7 @@ const getProperty = (moduleGraph, module, exportName, property, runtime) => {
 class ExportsInfoDependency extends NullDependency {
 	/**
 	 * @param {Range} range range
-	 * @param {TODO} exportName export name
+	 * @param {string[] | null} exportName export name
 	 * @param {string | null} property property
 	 */
 	constructor(range, exportName, property) {

package/lib/dependencies/ExternalModuleDependency.js

@@ -14,11 +14,20 @@ const ExternalModuleInitFragment = require("./ExternalModuleInitFragment");
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 class ExternalModuleDependency extends CachedConstDependency {
+	/**
+	 * @param {string} module module
+	 * @param {{ name: string, value: string }[]} importSpecifiers import specifiers
+	 * @param {string | undefined} defaultImport default import
+	 * @param {string} expression expression
+	 * @param {Range} range range
+	 * @param {string} identifier identifier
+	 */
 	constructor(
 		module,
 		importSpecifiers,

package/lib/dependencies/ExternalModuleInitFragment.js

@@ -9,11 +9,14 @@ const InitFragment = require("../InitFragment");
 const makeSerializable = require("../util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../Generator").GenerateContext} Context */
+/** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {Map<string, Set<string>>} ImportSpecifiers */
 
+/**
+ * @extends {InitFragment<GenerateContext>}
+ */
 class ExternalModuleInitFragment extends InitFragment {
 	/**
 	 * @param {string} importedModule imported module
@@ -45,6 +48,10 @@ class ExternalModuleInitFragment extends InitFragment {
 		this.defaultImport = defaultImport;
 	}
 
+	/**
+	 * @param {ExternalModuleInitFragment} other other
+	 * @returns {ExternalModuleInitFragment} ExternalModuleInitFragment
+	 */
 	merge(other) {
 		const newSpecifiersMap = new Map(this.specifiers);
 		for (const [name, specifiers] of other.specifiers) {
@@ -63,8 +70,8 @@ class ExternalModuleInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source} the source code that will be included as initialization code
 	 */
 	getContent({ runtimeRequirements }) {
 		const namedImports = [];

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -130,8 +130,8 @@ class HarmonyExportInitFragment extends InitFragment {
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source} the source code that will be included as initialization code
 	 */
 	getContent({ runtimeTemplate, runtimeRequirements }) {
 		runtimeRequirements.add(RuntimeGlobals.exports);

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -192,7 +192,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 			for (const key of this.referencedPropertiesInDestructuring) {
 				refs.push({
 					name: ids ? ids.concat([key]) : [key],
-					canMangle: false
+					canMangle: Array.isArray(ids) && ids.length > 0
 				});
 			}
 			return refs;

package/lib/dependencies/ImportParserPlugin.js

@@ -287,6 +287,7 @@ class ImportParserPlugin {
 						exports
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = !!parser.scope.inTry;
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
 				}

package/lib/dependencies/LocalModuleDependency.js

@@ -19,7 +19,7 @@ const NullDependency = require("./NullDependency");
 class LocalModuleDependency extends NullDependency {
 	/**
 	 * @param {LocalModule} localModule local module
-	 * @param {Range} range range
+	 * @param {Range | undefined} range range
 	 * @param {boolean} callNew true, when the local module should be called with new
 	 */
 	constructor(localModule, range, callNew) {

package/lib/dependencies/WorkerPlugin.js

@@ -184,8 +184,9 @@ class WorkerPlugin {
 						}
 					}
 					const insertType = expr.properties.length > 0 ? "comma" : "single";
-					const insertLocation =
-						expr.properties[expr.properties.length - 1].range[1];
+					const insertLocation = /** @type {Range} */ (
+						expr.properties[expr.properties.length - 1].range
+					)[1];
 					return {
 						expressions,
 						otherElements,

package/lib/dependencies/getFunctionExpression.js

@@ -9,8 +9,8 @@
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 
 /**
- * @param {Expression} expr expressions
- * @returns {{fn: TODO, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined }} function expression with additional information
+ * @param {Expression | SpreadElement} expr expressions
+ * @returns {{fn: TODO, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined } | undefined} function expression with additional information
  */
 module.exports = expr => {
 	// <FunctionExpression>

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -215,7 +215,7 @@ module.exports = function () {
 		for (var i = 0; i < registeredStatusHandlers.length; i++)
 			results[i] = registeredStatusHandlers[i].call(null, newStatus);
 
-		return Promise.all(results);
+		return Promise.all(results).then(function () {});
 	}
 
 	function unblock() {