webpack 5.76.1 → 5.88.2

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -29,8 +29,14 @@ const RequireResolveContextDependency = require("./RequireResolveContextDependen
 const RequireResolveDependency = require("./RequireResolveDependency");
 const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
 
-/** @typedef {import("estree").CallExpression} CallExpressionNode */
+/** @typedef {import("estree").CallExpression} CallExpression */
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").NewExpression} NewExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").ImportSource} ImportSource */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const createRequireSpecifierTag = Symbol("createRequire");
 const createdRequireIdentifierTag = Symbol("createRequire()");
@@ -43,6 +49,10 @@ class CommonJsImportsParserPlugin {
 		this.options = options;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
 		const options = this.options;
 
@@ -54,6 +64,10 @@ class CommonJsImportsParserPlugin {
 		};
 
 		//#region metadata
+		/**
+		 * @param {TODO} expression expression
+		 * @param {() => string[]} getMembers get members
+		 */
 		const tapRequireExpression = (expression, getMembers) => {
 			parser.hooks.typeof
 				.for(expression)
@@ -71,6 +85,9 @@ class CommonJsImportsParserPlugin {
 					evaluateToIdentifier(expression, "require", getMembers, true)
 				);
 		};
+		/**
+		 * @param {string | symbol} tag tag
+		 */
 		const tapRequireExpressionTag = tag => {
 			parser.hooks.typeof
 				.for(tag)
@@ -93,7 +110,7 @@ class CommonJsImportsParserPlugin {
 			.tap("CommonJsImportsParserPlugin", expr => {
 				// to not leak to global "require", we need to define a local require here.
 				const dep = new ConstDependency("var require;", 0);
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			});
@@ -138,10 +155,17 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Renaming
+		/**
+		 * @param {Expression} expr expression
+		 * @returns {boolean} true when set undefined
+		 */
 		const defineUndefined = expr => {
 			// To avoid "not defined" error, replace the value with undefined
-			const dep = new ConstDependency("undefined", expr.range);
-			dep.loc = expr.loc;
+			const dep = new ConstDependency(
+				"undefined",
+				/** @type {Range} */ (expr.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			parser.state.module.addPresentationalDependency(dep);
 			return false;
 		};
@@ -170,6 +194,10 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Require as expression
+		/**
+		 * @param {Expression} expr expression
+		 * @returns {boolean} true when handled
+		 */
 		const requireAsExpressionHandler = expr => {
 			const dep = new CommonJsRequireContextDependency(
 				{
@@ -178,7 +206,7 @@ class CommonJsImportsParserPlugin {
 					regExp: options.unknownContextRegExp,
 					mode: "sync"
 				},
-				expr.range,
+				/** @type {Range} */ (expr.range),
 				undefined,
 				parser.scope.inShorthand,
 				getContext()
@@ -186,7 +214,7 @@ class CommonJsImportsParserPlugin {
 			dep.critical =
 				options.unknownContextCritical &&
 				"require function is used in a way in which dependencies cannot be statically extracted";
-			dep.loc = expr.loc;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			dep.optional = !!parser.scope.inTry;
 			parser.state.current.addDependency(dep);
 			return true;
@@ -197,23 +225,33 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Require
+		/**
+		 * @param {CallExpression | NewExpression} expr expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @returns {boolean | void} true when handled
+		 */
 		const processRequireItem = (expr, param) => {
 			if (param.isString()) {
 				const dep = new CommonJsRequireDependency(
-					param.string,
-					param.range,
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (param.range),
 					getContext()
 				);
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.optional = !!parser.scope.inTry;
 				parser.state.current.addDependency(dep);
 				return true;
 			}
 		};
+		/**
+		 * @param {CallExpression | NewExpression} expr expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @returns {boolean | void} true when handled
+		 */
 		const processRequireContext = (expr, param) => {
 			const dep = ContextDependencyHelpers.create(
 				CommonJsRequireContextDependency,
-				expr.range,
+				/** @type {Range} */ (expr.range),
 				param,
 				expr,
 				options,
@@ -225,15 +263,19 @@ class CommonJsImportsParserPlugin {
 				getContext()
 			);
 			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 {boolean} callNew true, when require is called with new
+		 * @returns {(expr: CallExpression | NewExpression) => (boolean | void)} handler
+		 */
 		const createRequireHandler = callNew => expr => {
 			if (options.commonjsMagicComments) {
 				const { options: requireOptions, errors: commentErrors } =
-					parser.parseCommentOptions(expr.range);
+					parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
 				if (commentErrors) {
 					for (const e of commentErrors) {
@@ -252,7 +294,7 @@ class CommonJsImportsParserPlugin {
 							parser.state.module.addWarning(
 								new UnsupportedFeatureWarning(
 									`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
-									expr.loc
+									/** @type {DependencyLocation} */ (expr.loc)
 								)
 							);
 						} else {
@@ -270,26 +312,37 @@ class CommonJsImportsParserPlugin {
 			const param = parser.evaluateExpression(expr.arguments[0]);
 			if (param.isConditional()) {
 				let isExpression = false;
-				for (const p of param.options) {
+				for (const p of /** @type {BasicEvaluatedExpression[]} */ (
+					param.options
+				)) {
 					const result = processRequireItem(expr, p);
 					if (result === undefined) {
 						isExpression = true;
 					}
 				}
 				if (!isExpression) {
-					const dep = new RequireHeaderDependency(expr.callee.range);
-					dep.loc = expr.loc;
+					const dep = new RequireHeaderDependency(
+						/** @type {Range} */ (expr.callee.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addPresentationalDependency(dep);
 					return true;
 				}
 			}
 			if (
 				param.isString() &&
-				(localModule = getLocalModule(parser.state, param.string))
+				(localModule = getLocalModule(
+					parser.state,
+					/** @type {string} */ (param.string)
+				))
 			) {
 				localModule.flagUsed();
-				const dep = new LocalModuleDependency(localModule, expr.range, callNew);
-				dep.loc = expr.loc;
+				const dep = new LocalModuleDependency(
+					localModule,
+					/** @type {Range} */ (expr.range),
+					callNew
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			} else {
@@ -297,8 +350,10 @@ class CommonJsImportsParserPlugin {
 				if (result === undefined) {
 					processRequireContext(expr, param);
 				} else {
-					const dep = new RequireHeaderDependency(expr.callee.range);
-					dep.loc = expr.loc;
+					const dep = new RequireHeaderDependency(
+						/** @type {Range} */ (expr.callee.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					parser.state.module.addPresentationalDependency(dep);
 				}
 				return true;
@@ -319,35 +374,59 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Require with property access
+		/**
+		 * @param {Expression} expr expression
+		 * @param {string[]} calleeMembers callee members
+		 * @param {CallExpression} callExpr call expression
+		 * @param {string[]} members members
+		 * @returns {boolean | void} true when handled
+		 */
 		const chainHandler = (expr, calleeMembers, callExpr, members) => {
 			if (callExpr.arguments.length !== 1) return;
 			const param = parser.evaluateExpression(callExpr.arguments[0]);
-			if (param.isString() && !getLocalModule(parser.state, param.string)) {
+			if (
+				param.isString() &&
+				!getLocalModule(parser.state, /** @type {string} */ (param.string))
+			) {
 				const dep = new CommonJsFullRequireDependency(
-					param.string,
-					expr.range,
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (expr.range),
 					members
 				);
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
 				dep.optional = !!parser.scope.inTry;
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.current.addDependency(dep);
 				return true;
 			}
 		};
+		/**
+		 * @param {CallExpression} expr expression
+		 * @param {string[]} calleeMembers callee members
+		 * @param {CallExpression} callExpr call expression
+		 * @param {string[]} members members
+		 * @returns {boolean | void} true when handled
+		 */
 		const callChainHandler = (expr, calleeMembers, callExpr, members) => {
 			if (callExpr.arguments.length !== 1) return;
 			const param = parser.evaluateExpression(callExpr.arguments[0]);
-			if (param.isString() && !getLocalModule(parser.state, param.string)) {
+			if (
+				param.isString() &&
+				!getLocalModule(parser.state, /** @type {string} */ (param.string))
+			) {
 				const dep = new CommonJsFullRequireDependency(
-					param.string,
-					expr.callee.range,
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (expr.callee.range),
 					members
 				);
 				dep.call = true;
-				dep.asiSafe = !parser.isAsiPosition(expr.range[0]);
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
 				dep.optional = !!parser.scope.inTry;
-				dep.loc = expr.callee.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.callee.loc);
 				parser.state.current.addDependency(dep);
 				parser.walkExpressions(expr.arguments);
 				return true;
@@ -368,18 +447,27 @@ class CommonJsImportsParserPlugin {
 		//#endregion
 
 		//#region Require.resolve
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
 		const processResolve = (expr, weak) => {
 			if (expr.arguments.length !== 1) return;
 			const param = parser.evaluateExpression(expr.arguments[0]);
 			if (param.isConditional()) {
-				for (const option of param.options) {
+				for (const option of /** @type {BasicEvaluatedExpression[]} */ (
+					param.options
+				)) {
 					const result = processResolveItem(expr, option, weak);
 					if (result === undefined) {
 						processResolveContext(expr, option, weak);
 					}
 				}
-				const dep = new RequireResolveHeaderDependency(expr.callee.range);
-				dep.loc = expr.loc;
+				const dep = new RequireResolveHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			} else {
@@ -387,30 +475,44 @@ class CommonJsImportsParserPlugin {
 				if (result === undefined) {
 					processResolveContext(expr, param, weak);
 				}
-				const dep = new RequireResolveHeaderDependency(expr.callee.range);
-				dep.loc = expr.loc;
+				const dep = new RequireResolveHeaderDependency(
+					/** @type {Range} */ (expr.callee.range)
+				);
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(dep);
 				return true;
 			}
 		};
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
 		const processResolveItem = (expr, param, weak) => {
 			if (param.isString()) {
 				const dep = new RequireResolveDependency(
-					param.string,
-					param.range,
+					/** @type {string} */ (param.string),
+					/** @type {Range} */ (param.range),
 					getContext()
 				);
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.optional = !!parser.scope.inTry;
 				dep.weak = weak;
 				parser.state.current.addDependency(dep);
 				return true;
 			}
 		};
+		/**
+		 * @param {CallExpression} expr call expression
+		 * @param {BasicEvaluatedExpression} param param
+		 * @param {boolean} weak weak
+		 * @returns {boolean | void} true when handled
+		 */
 		const processResolveContext = (expr, param, weak) => {
 			const dep = ContextDependencyHelpers.create(
 				RequireResolveContextDependency,
-				param.range,
+				/** @type {Range} */ (param.range),
 				param,
 				expr,
 				options,
@@ -422,7 +524,7 @@ class CommonJsImportsParserPlugin {
 				getContext()
 			);
 			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;
@@ -444,13 +546,16 @@ class CommonJsImportsParserPlugin {
 
 		if (!options.createRequire) return;
 
-		let moduleName;
+		/** @type {ImportSource[]} */
+		let moduleName = [];
+		/** @type {string | undefined} */
 		let specifierName;
 
 		if (options.createRequire === true) {
-			moduleName = "module";
+			moduleName = ["module", "node:module"];
 			specifierName = "createRequire";
 		} else {
+			let moduleName;
 			const match = /^(.*) from (.*)$/.exec(options.createRequire);
 			if (match) {
 				[, specifierName, moduleName] = match;
@@ -480,9 +585,13 @@ class CommonJsImportsParserPlugin {
 					next: undefined
 				});
 				return new BasicEvaluatedExpression()
-					.setIdentifier(ident, ident, () => [])
+					.setIdentifier(
+						/** @type {TODO} */ (ident),
+						/** @type {TODO} */ (ident),
+						() => []
+					)
 					.setSideEffects(false)
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		parser.hooks.unhandledExpressionMemberChain
 			.for(createdRequireIdentifierTag)
@@ -508,8 +617,8 @@ class CommonJsImportsParserPlugin {
 			.for(createdRequireIdentifierTag)
 			.tap("CommonJsImportsParserPlugin", createRequireHandler(false));
 		/**
-		 * @param {CallExpressionNode} expr call expression
-		 * @returns {string} context
+		 * @param {CallExpression} expr call expression
+		 * @returns {string | void} context
 		 */
 		const parseCreateRequireArguments = expr => {
 			const args = expr.arguments;
@@ -517,7 +626,7 @@ class CommonJsImportsParserPlugin {
 				const err = new WebpackError(
 					"module.createRequire supports only one argument."
 				);
-				err.loc = expr.loc;
+				err.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addWarning(err);
 				return;
 			}
@@ -527,13 +636,13 @@ class CommonJsImportsParserPlugin {
 				const err = new WebpackError(
 					"module.createRequire failed parsing argument."
 				);
-				err.loc = arg.loc;
+				err.loc = /** @type {DependencyLocation} */ (arg.loc);
 				parser.state.module.addWarning(err);
 				return;
 			}
-			const ctx = evaluated.string.startsWith("file://")
-				? fileURLToPath(evaluated.string)
-				: evaluated.string;
+			const ctx = /** @type {string} */ (evaluated.string).startsWith("file://")
+				? fileURLToPath(/** @type {string} */ (evaluated.string))
+				: /** @type {string} */ (evaluated.string);
 			// argument always should be a filename
 			return ctx.slice(0, ctx.lastIndexOf(ctx.startsWith("/") ? "/" : "\\"));
 		};
@@ -545,7 +654,7 @@ class CommonJsImportsParserPlugin {
 			},
 			(statement, source) => {
 				if (
-					source !== moduleName ||
+					!moduleName.includes(source) ||
 					statement.specifiers.length !== 1 ||
 					statement.specifiers[0].type !== "ImportSpecifier" ||
 					statement.specifiers[0].imported.type !== "Identifier" ||
@@ -555,12 +664,14 @@ class CommonJsImportsParserPlugin {
 				// clear for 'import { createRequire as x } from "module"'
 				// if any other specifier was used import module
 				const clearDep = new ConstDependency(
-					parser.isAsiPosition(statement.range[0]) ? ";" : "",
-					statement.range
+					parser.isAsiPosition(/** @type {Range} */ (statement.range)[0])
+						? ";"
+						: "",
+					/** @type {Range} */ (statement.range)
 				);
-				clearDep.loc = statement.loc;
+				clearDep.loc = /** @type {DependencyLocation} */ (statement.loc);
 				parser.state.module.addPresentationalDependency(clearDep);
-				parser.unsetAsiPosition(statement.range[1]);
+				parser.unsetAsiPosition(/** @type {Range} */ (statement.range)[1]);
 				return true;
 			}
 		);
@@ -570,7 +681,7 @@ class CommonJsImportsParserPlugin {
 				stage: -10
 			},
 			(statement, source, id, name) => {
-				if (source !== moduleName || id !== specifierName) return;
+				if (!moduleName.includes(source) || id !== specifierName) return;
 				parser.tagVariable(name, createRequireSpecifierTag);
 				return true;
 			}
@@ -585,9 +696,9 @@ class CommonJsImportsParserPlugin {
 					declarator.init.callee.type !== "Identifier"
 				)
 					return;
-				const variableInfo = parser.getVariableInfo(
-					declarator.init.callee.name
-				);
+				const variableInfo =
+					/** @type {TODO} */
+					(parser.getVariableInfo(declarator.init.callee.name));
 				if (
 					variableInfo &&
 					variableInfo.tagInfo &&
@@ -657,9 +768,9 @@ class CommonJsImportsParserPlugin {
 			.tap("CommonJsImportsParserPlugin", expr => {
 				const clearDep = new ConstDependency(
 					"/* createRequire() */ undefined",
-					expr.range
+					/** @type {Range} */ (expr.range)
 				);
-				clearDep.loc = expr.loc;
+				clearDep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addPresentationalDependency(clearDep);
 				return true;
 			});