webpack 5.92.1 → 5.94.0

package/lib/javascript/JavascriptParser.js

@@ -159,11 +159,9 @@ class VariableInfo {
  * Helper function for joining two ranges into a single range. This is useful
  * when working with AST nodes, as it allows you to combine the ranges of child nodes
  * to create the range of the _parent node_.
- *
  * @param {[number, number]} startRange start range to join
  * @param {[number, number]} endRange end range to join
  * @returns {[number, number]} joined range
- *
  * @example
  * ```js
  * 	const startRange = [0, 5];
@@ -171,7 +169,6 @@ class VariableInfo {
  * 	const joinedRange = joinRanges(startRange, endRange);
  * 	console.log(joinedRange); // [0, 15]
  * ```
- *
  */
 const joinRanges = (startRange, endRange) => {
 	if (!endRange) return startRange;
@@ -182,7 +179,6 @@ const joinRanges = (startRange, endRange) => {
 /**
  * Helper function used to generate a string representation of a
  * [member expression](https://github.com/estree/estree/blob/master/es5.md#memberexpression).
- *
  * @param {string} object object to name
  * @param {string[]} membersReversed reversed list of members
  * @returns {string} member expression as a string
@@ -193,12 +189,11 @@ const joinRanges = (startRange, endRange) => {
  *
  * console.log(name); // "myObject.property1.property2.property3"
  * ```
- *
  */
 const objectAndMembersToName = (object, membersReversed) => {
 	let name = object;
 	for (let i = membersReversed.length - 1; i >= 0; i--) {
-		name = name + "." + membersReversed[i];
+		name = `${name}.${membersReversed[i]}`;
 	}
 	return name;
 };
@@ -209,8 +204,7 @@ const objectAndMembersToName = (object, membersReversed) => {
  * [ThisExpressions](https://github.com/estree/estree/blob/master/es5.md#identifier), and
  * [MetaProperties](https://github.com/estree/estree/blob/master/es2015.md#metaproperty) which is
  * specifically for handling the `new.target` meta property.
- *
- * @param {Expression | Super} expression expression
+ * @param {Expression | SpreadElement | Super} expression expression
  * @returns {string | "this" | undefined} name or variable info
  */
 const getRootName = expression => {
@@ -254,7 +248,7 @@ class JavascriptParser extends Parser {
 		this.hooks = Object.freeze({
 			/** @type {HookMap<SyncBailHook<[UnaryExpression], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[Expression], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[Expression | SpreadElement], BasicEvaluatedExpression | undefined | null>>} */
 			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
 			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression | MetaProperty], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
@@ -504,7 +498,7 @@ class JavascriptParser extends Parser {
 			)
 				return;
 
-			let regExp, flags;
+			let regExp;
 			const arg1 = expr.arguments[0];
 
 			if (arg1) {
@@ -518,11 +512,15 @@ class JavascriptParser extends Parser {
 
 				if (!regExp) return;
 			} else {
-				return new BasicEvaluatedExpression()
-					.setRegExp(new RegExp(""))
-					.setRange(/** @type {Range} */ (expr.range));
+				return (
+					new BasicEvaluatedExpression()
+						// eslint-disable-next-line prefer-regex-literals
+						.setRegExp(new RegExp(""))
+						.setRange(/** @type {Range} */ (expr.range))
+				);
 			}
 
+			let flags;
 			const arg2 = expr.arguments[1];
 
 			if (arg2) {
@@ -669,7 +667,6 @@ class JavascriptParser extends Parser {
 
 				/**
 				 * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
-				 *
 				 * @template T
 				 * @param {(leftOperand: T, rightOperand: T) => boolean | number | bigint | string} operandHandler the handler for the operation (e.g. (a, b) => a + b)
 				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
@@ -695,7 +692,6 @@ class JavascriptParser extends Parser {
 				/**
 				 * Helper function to determine if two booleans are always different. This is used in `handleStrictEqualityComparison`
 				 * to determine if an expressions boolean or nullish conversion is equal or not.
-				 *
 				 * @param {boolean} a first boolean to compare
 				 * @param {boolean} b second boolean to compare
 				 * @returns {boolean} true if the two booleans are always different, false otherwise
@@ -984,7 +980,7 @@ class JavascriptParser extends Parser {
 							res.setWrapped(
 								left.prefix,
 								new BasicEvaluatedExpression()
-									.setString(right.number + "")
+									.setString(String(right.number))
 									.setRange(/** @type {Range} */ (right.range)),
 								left.wrappedInnerExpressions
 							);
@@ -1013,25 +1009,23 @@ class JavascriptParser extends Parser {
 									)
 							);
 						}
+					} else if (right.isString()) {
+						// left + "right"
+						// => ([null] + left + "right")
+						res.setWrapped(null, right, [left]);
+					} else if (right.isWrapped()) {
+						// left + (prefix + inner + "postfix")
+						// => ([null] + left + prefix + inner + "postfix")
+						res.setWrapped(
+							null,
+							right.postfix,
+							right.wrappedInnerExpressions &&
+								(right.prefix ? [left, right.prefix] : [left]).concat(
+									right.wrappedInnerExpressions
+								)
+						);
 					} else {
-						if (right.isString()) {
-							// left + "right"
-							// => ([null] + left + "right")
-							res.setWrapped(null, right, [left]);
-						} else if (right.isWrapped()) {
-							// left + (prefix + inner + "postfix")
-							// => ([null] + left + prefix + inner + "postfix")
-							res.setWrapped(
-								null,
-								right.postfix,
-								right.wrappedInnerExpressions &&
-									(right.prefix ? [left, right.prefix] : [left]).concat(
-										right.wrappedInnerExpressions
-									)
-							);
-						} else {
-							return;
-						}
+						return;
 					}
 					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
 						res.setSideEffects();
@@ -1082,7 +1076,6 @@ class JavascriptParser extends Parser {
 
 				/**
 				 * Evaluates a UnaryExpression if and only if it is a basic const operator (e.g. +a, -a, ~a).
-				 *
 				 * @template T
 				 * @param {(operand: T) => boolean | number | bigint | string} operandHandler handler for the operand
 				 * @returns {BasicEvaluatedExpression | undefined} evaluated expression
@@ -1197,16 +1190,19 @@ class JavascriptParser extends Parser {
 				} else if (expr.operator === "~") {
 					return handleConstOperation(v => ~v);
 				} else if (expr.operator === "+") {
+					// eslint-disable-next-line no-implicit-coercion
 					return handleConstOperation(v => +v);
 				} else if (expr.operator === "-") {
 					return handleConstOperation(v => -v);
 				}
 			});
-		this.hooks.evaluateTypeof.for("undefined").tap("JavascriptParser", expr => {
-			return new BasicEvaluatedExpression()
-				.setString("undefined")
-				.setRange(/** @type {Range} */ (expr.range));
-		});
+		this.hooks.evaluateTypeof
+			.for("undefined")
+			.tap("JavascriptParser", expr =>
+				new BasicEvaluatedExpression()
+					.setString("undefined")
+					.setRange(/** @type {Range} */ (expr.range))
+			);
 		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
 			if (/** @type {Identifier} */ (expr).name === "undefined") {
 				return new BasicEvaluatedExpression()
@@ -1216,14 +1212,14 @@ class JavascriptParser extends Parser {
 		});
 		/**
 		 * @param {string} exprType expression type name
-		 * @param {function(Expression): GetInfoResult | undefined} getInfo get info
+		 * @param {function(Expression | SpreadElement): GetInfoResult | undefined} getInfo get info
 		 * @returns {void}
 		 */
 		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
 			/** @type {Expression | undefined} */
-			let cachedExpression = undefined;
+			let cachedExpression;
 			/** @type {GetInfoResult | undefined} */
-			let cachedInfo = undefined;
+			let cachedInfo;
 			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
 				const expression = /** @type {MemberExpression} */ (expr);
 
@@ -1375,8 +1371,8 @@ class JavascriptParser extends Parser {
 				if (expr.arguments.length !== 2) return;
 				if (expr.arguments[0].type === "SpreadElement") return;
 				if (expr.arguments[1].type === "SpreadElement") return;
-				let arg1 = this.evaluateExpression(expr.arguments[0]);
-				let arg2 = this.evaluateExpression(expr.arguments[1]);
+				const arg1 = this.evaluateExpression(expr.arguments[0]);
+				const arg2 = this.evaluateExpression(expr.arguments[1]);
 				if (!arg1.isString() && !arg1.isRegExp()) return;
 				const arg1Value = /** @type {string | RegExp} */ (
 					arg1.regExp || arg1.string
@@ -1390,14 +1386,14 @@ class JavascriptParser extends Parser {
 					.setSideEffects(param.couldHaveSideEffects())
 					.setRange(/** @type {Range} */ (expr.range));
 			});
-		["substr", "substring", "slice"].forEach(fn => {
+		for (const fn of ["substr", "substring", "slice"]) {
 			this.hooks.evaluateCallExpressionMember
 				.for(fn)
 				.tap("JavascriptParser", (expr, param) => {
 					if (!param.isString()) return;
 					let arg1;
-					let result,
-						str = /** @type {string} */ (param.string);
+					let result;
+					const str = /** @type {string} */ (param.string);
 					switch (expr.arguments.length) {
 						case 1:
 							if (expr.arguments[0].type === "SpreadElement") return;
@@ -1430,7 +1426,7 @@ class JavascriptParser extends Parser {
 						.setSideEffects(param.couldHaveSideEffects())
 						.setRange(/** @type {Range} */ (expr.range));
 				});
-		});
+		}
 
 		/**
 		 * @param {"cooked" | "raw"} kind kind of values to get
@@ -1538,7 +1534,7 @@ class JavascriptParser extends Parser {
 					/** @type {string} */
 					const value = argExpr.isString()
 						? /** @type {string} */ (argExpr.string)
-						: "" + /** @type {number} */ (argExpr.number);
+						: String(/** @type {number} */ (argExpr.number));
 
 					/** @type {string} */
 					const newString = value + (stringSuffix ? stringSuffix.string : "");
@@ -1572,18 +1568,17 @@ class JavascriptParser extends Parser {
 					return new BasicEvaluatedExpression()
 						.setWrapped(param.prefix, postfix, inner)
 						.setRange(/** @type {Range} */ (expr.range));
-				} else {
-					const newString =
-						/** @type {string} */ (param.string) +
-						(stringSuffix ? stringSuffix.string : "");
-					return new BasicEvaluatedExpression()
-						.setString(newString)
-						.setSideEffects(
-							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
-								param.couldHaveSideEffects()
-						)
-						.setRange(/** @type {Range} */ (expr.range));
 				}
+				const newString =
+					/** @type {string} */ (param.string) +
+					(stringSuffix ? stringSuffix.string : "");
+				return new BasicEvaluatedExpression()
+					.setString(newString)
+					.setSideEffects(
+						(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
+							param.couldHaveSideEffects()
+					)
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		this.hooks.evaluateCallExpressionMember
 			.for("split")
@@ -1649,13 +1644,12 @@ class JavascriptParser extends Parser {
 			.tap("JavascriptParser", _expr => {
 				const expr = /** @type {ArrayExpression} */ (_expr);
 
-				const items = expr.elements.map(element => {
-					return (
+				const items = expr.elements.map(
+					element =>
 						element !== null &&
 						element.type !== "SpreadElement" &&
 						this.evaluateExpression(element)
-					);
-				});
+				);
 				if (!items.every(Boolean)) return;
 				return new BasicEvaluatedExpression()
 					.setItems(/** @type {BasicEvaluatedExpression[]} */ (items))
@@ -1712,7 +1706,7 @@ class JavascriptParser extends Parser {
 	 * @returns {Set<DestructuringAssignmentProperty> | undefined} destructured identifiers
 	 */
 	destructuringAssignmentPropertiesFor(node) {
-		if (!this.destructuringAssignmentProperties) return undefined;
+		if (!this.destructuringAssignmentProperties) return;
 		return this.destructuringAssignmentProperties.get(node);
 	}
 
@@ -1732,10 +1726,11 @@ class JavascriptParser extends Parser {
 	 * @returns {void}
 	 */
 	walkClass(classy) {
-		if (classy.superClass) {
-			if (!this.hooks.classExtendsExpression.call(classy.superClass, classy)) {
-				this.walkExpression(classy.superClass);
-			}
+		if (
+			classy.superClass &&
+			!this.hooks.classExtendsExpression.call(classy.superClass, classy)
+		) {
+			this.walkExpression(classy.superClass);
 		}
 		if (classy.body && classy.body.type === "ClassBody") {
 			const scopeParams = [];
@@ -1776,7 +1771,6 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * Pre walking iterates the scope for variable declarations
-	 *
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
 	 */
 	preWalkStatements(statements) {
@@ -1788,7 +1782,6 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * Block pre walking iterates the scope for block variable declarations
-	 *
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
 	 */
 	blockPreWalkStatements(statements) {
@@ -1800,7 +1793,6 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * Walking iterates the statements and expressions and processes them
-	 *
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
 	 */
 	walkStatements(statements) {
@@ -1812,7 +1804,6 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * Walking iterates the statements and expressions and processes them
-	 *
 	 * @param {Statement | ModuleDeclaration} statement statement
 	 */
 	preWalkStatement(statement) {
@@ -1974,7 +1965,6 @@ class JavascriptParser extends Parser {
 	 * Walks a statements that is nested within a parent statement
 	 * and can potentially be a non-block statement.
 	 * This enforces the nested statement to never be in ASI position.
-	 *
 	 * @param {Statement} statement the nested statement
 	 */
 	walkNestedStatement(statement) {
@@ -2031,12 +2021,10 @@ class JavascriptParser extends Parser {
 			if (statement.alternate) {
 				this.walkNestedStatement(statement.alternate);
 			}
-		} else {
-			if (result) {
-				this.walkNestedStatement(statement.consequent);
-			} else if (statement.alternate) {
-				this.walkNestedStatement(statement.alternate);
-			}
+		} else if (result) {
+			this.walkNestedStatement(statement.consequent);
+		} else if (statement.alternate) {
+			this.walkNestedStatement(statement.alternate);
 		}
 	}
 
@@ -2168,10 +2156,8 @@ class JavascriptParser extends Parser {
 	 * @param {ForStatement} statement for statement
 	 */
 	preWalkForStatement(statement) {
-		if (statement.init) {
-			if (statement.init.type === "VariableDeclaration") {
-				this.preWalkStatement(statement.init);
-			}
+		if (statement.init && statement.init.type === "VariableDeclaration") {
+			this.preWalkStatement(statement.init);
 		}
 		this.preWalkStatement(statement.body);
 	}
@@ -2438,19 +2424,18 @@ class JavascriptParser extends Parser {
 		} else {
 			this.hooks.export.call(statement);
 		}
-		if (statement.declaration) {
-			if (
-				!this.hooks.exportDeclaration.call(statement, statement.declaration)
-			) {
-				const prev = this.prevStatement;
-				this.preWalkStatement(statement.declaration);
-				this.prevStatement = prev;
-				this.blockPreWalkStatement(statement.declaration);
-				let index = 0;
-				this.enterDeclaration(statement.declaration, def => {
-					this.hooks.exportSpecifier.call(statement, def, def, index++);
-				});
-			}
+		if (
+			statement.declaration &&
+			!this.hooks.exportDeclaration.call(statement, statement.declaration)
+		) {
+			const prev = this.prevStatement;
+			this.preWalkStatement(statement.declaration);
+			this.prevStatement = prev;
+			this.blockPreWalkStatement(statement.declaration);
+			let index = 0;
+			this.enterDeclaration(statement.declaration, def => {
+				this.hooks.exportSpecifier.call(statement, def, def, index++);
+			});
 		}
 		if (statement.specifiers) {
 			for (
@@ -3111,11 +3096,13 @@ class JavascriptParser extends Parser {
 				currentStatement.expression === expression)
 		) {
 			const old = /** @type {StatementPathItem} */ (this.statementPath.pop());
+			const prev = this.prevStatement;
 			for (const expr of expression.expressions) {
 				this.statementPath.push(expr);
 				this.walkExpression(expr);
-				this.statementPath.pop();
+				this.prevStatement = this.statementPath.pop();
 			}
+			this.prevStatement = prev;
 			this.statementPath.push(old);
 		} else {
 			this.walkExpressions(expression.expressions);
@@ -3176,10 +3163,8 @@ class JavascriptParser extends Parser {
 		const result = this.hooks.expressionLogicalOperator.call(expression);
 		if (result === undefined) {
 			this.walkLeftRightExpression(expression);
-		} else {
-			if (result) {
-				this.walkExpression(expression.right);
-			}
+		} else if (result) {
+			this.walkExpression(expression.right);
 		}
 	}
 
@@ -3189,31 +3174,30 @@ class JavascriptParser extends Parser {
 	walkAssignmentExpression(expression) {
 		if (expression.left.type === "Identifier") {
 			const renameIdentifier = this.getRenameIdentifier(expression.right);
-			if (renameIdentifier) {
+			if (
+				renameIdentifier &&
+				this.callHooksForInfo(
+					this.hooks.canRename,
+					renameIdentifier,
+					expression.right
+				)
+			) {
+				// renaming "a = b;"
 				if (
-					this.callHooksForInfo(
-						this.hooks.canRename,
+					!this.callHooksForInfo(
+						this.hooks.rename,
 						renameIdentifier,
 						expression.right
 					)
 				) {
-					// renaming "a = b;"
-					if (
-						!this.callHooksForInfo(
-							this.hooks.rename,
-							renameIdentifier,
-							expression.right
-						)
-					) {
-						this.setVariable(
-							expression.left.name,
-							typeof renameIdentifier === "string"
-								? this.getVariableInfo(renameIdentifier)
-								: renameIdentifier
-						);
-					}
-					return;
+					this.setVariable(
+						expression.left.name,
+						typeof renameIdentifier === "string"
+							? this.getVariableInfo(renameIdentifier)
+							: renameIdentifier
+					);
 				}
+				return;
 			}
 			this.walkExpression(expression.right);
 			this.enterPattern(expression.left, (name, decl) => {
@@ -3236,17 +3220,16 @@ class JavascriptParser extends Parser {
 				expression.left,
 				ALLOWED_MEMBER_TYPES_EXPRESSION
 			);
-			if (exprName) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.assignMemberChain,
-						exprName.rootInfo,
-						expression,
-						exprName.getMembers()
-					)
-				) {
-					return;
-				}
+			if (
+				exprName &&
+				this.callHooksForInfo(
+					this.hooks.assignMemberChain,
+					exprName.rootInfo,
+					expression,
+					exprName.getMembers()
+				)
+			) {
+				return;
 			}
 			this.walkExpression(expression.right);
 			this.walkExpression(expression.left);
@@ -3267,12 +3250,10 @@ class JavascriptParser extends Parser {
 			if (expression.alternate) {
 				this.walkExpression(expression.alternate);
 			}
-		} else {
-			if (result) {
-				this.walkExpression(expression.consequent);
-			} else if (expression.alternate) {
-				this.walkExpression(expression.alternate);
-			}
+		} else if (result) {
+			this.walkExpression(expression.consequent);
+		} else if (expression.alternate) {
+			this.walkExpression(expression.alternate);
 		}
 	}
 
@@ -3361,26 +3342,18 @@ class JavascriptParser extends Parser {
 			const renameIdentifier = this.getRenameIdentifier(
 				/** @type {Expression} */ (argOrThis)
 			);
-			if (renameIdentifier) {
-				if (
-					this.callHooksForInfo(
-						this.hooks.canRename,
-						renameIdentifier,
-						argOrThis
-					)
-				) {
-					if (
-						!this.callHooksForInfo(
-							this.hooks.rename,
-							renameIdentifier,
-							argOrThis
-						)
-					) {
-						return typeof renameIdentifier === "string"
-							? /** @type {string} */ (this.getVariableInfo(renameIdentifier))
-							: renameIdentifier;
-					}
-				}
+			if (
+				renameIdentifier &&
+				this.callHooksForInfo(
+					this.hooks.canRename,
+					renameIdentifier,
+					argOrThis
+				) &&
+				!this.callHooksForInfo(this.hooks.rename, renameIdentifier, argOrThis)
+			) {
+				return typeof renameIdentifier === "string"
+					? /** @type {string} */ (this.getVariableInfo(renameIdentifier))
+					: renameIdentifier;
 			}
 			this.walkExpression(argOrThis);
 		};
@@ -3429,7 +3402,7 @@ class JavascriptParser extends Parser {
 	 * @param {ImportExpression} expression import expression
 	 */
 	walkImportExpression(expression) {
-		let result = this.hooks.importCall.call(expression);
+		const result = this.hooks.importCall.call(expression);
 		if (result === true) return;
 
 		this.walkExpression(expression.source);
@@ -3439,9 +3412,8 @@ class JavascriptParser extends Parser {
 	 * @param {CallExpression} expression expression
 	 */
 	walkCallExpression(expression) {
-		const isSimpleFunction = fn => {
-			return fn.params.every(p => p.type === "Identifier");
-		};
+		const isSimpleFunction = fn =>
+			fn.params.every(p => p.type === "Identifier");
 		if (
 			expression.callee.type === "MemberExpression" &&
 			expression.callee.object.type.endsWith("FunctionExpression") &&
@@ -3656,6 +3628,7 @@ class JavascriptParser extends Parser {
 	walkMetaProperty(metaProperty) {
 		this.hooks.expression.for(getRootName(metaProperty)).call(metaProperty);
 	}
+
 	/**
 	 * @template T
 	 * @template R
@@ -4060,7 +4033,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {TODO} expression expression node
+	 * @param {Expression | SpreadElement} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
@@ -4073,8 +4046,8 @@ class JavascriptParser extends Parser {
 					return result;
 				}
 			}
-		} catch (e) {
-			console.warn(e);
+		} catch (err) {
+			console.warn(err);
 			// ignore error
 		}
 		return new BasicEvaluatedExpression()
@@ -4097,10 +4070,10 @@ class JavascriptParser extends Parser {
 				}
 				break;
 			case "Literal":
-				return expression.value + "";
+				return String(expression.value);
 		}
 		throw new Error(
-			expression.type + " is not supported as parameter for require"
+			`${expression.type} is not supported as parameter for require`
 		);
 	}
 
@@ -4131,14 +4104,13 @@ class JavascriptParser extends Parser {
 							code: true,
 							conditional: false
 						};
-					} else {
-						return {
-							range: [left.range[0], right.range[1]],
-							value: left.value + right.value,
-							code: false,
-							conditional: false
-						};
 					}
+					return {
+						range: [left.range[0], right.range[1]],
+						value: left.value + right.value,
+						code: false,
+						conditional: false
+					};
 				}
 				break;
 			case "ConditionalExpression": {
@@ -4169,7 +4141,7 @@ class JavascriptParser extends Parser {
 			case "Literal":
 				return {
 					range: expression.range,
-					value: expression.value + "",
+					value: String(expression.value),
 					code: false,
 					conditional: false
 				};
@@ -4256,7 +4228,7 @@ class JavascriptParser extends Parser {
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluate(source) {
-		const ast = JavascriptParser._parse("(" + source + ")", {
+		const ast = JavascriptParser._parse(`(${source})`, {
 			sourceType: this.sourceType,
 			locations: false
 		});
@@ -4409,7 +4381,7 @@ class JavascriptParser extends Parser {
 		const comments = /** @type {Comment[]} */ (this.comments);
 		let idx = binarySearchBounds.ge(comments, rangeStart, compare);
 		/** @type {Comment[]} */
-		let commentsInRange = [];
+		const commentsInRange = [];
 		while (
 			comments[idx] &&
 			/** @type {Range} */ (comments[idx].range)[1] <= rangeEnd
@@ -4444,6 +4416,14 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * @param {number} pos source code position
+	 * @returns {void}
+	 */
+	setAsiPosition(pos) {
+		/** @type {Set<number>} */ (this.semicolons).add(pos);
+	}
+
 	/**
 	 * @param {number} pos source code position
 	 * @returns {void}
@@ -4551,9 +4531,8 @@ class JavascriptParser extends Parser {
 		const value = this.scope.definitions.get(name);
 		if (value === undefined) {
 			return name;
-		} else {
-			return value;
 		}
+		return value;
 	}
 
 	/**
@@ -4593,9 +4572,9 @@ class JavascriptParser extends Parser {
 		if (comments.length === 0) {
 			return EMPTY_COMMENT_OPTIONS;
 		}
-		let options = {};
+		const options = {};
 		/** @type {unknown[]} */
-		let errors = [];
+		const errors = [];
 		for (const comment of comments) {
 			const { value } = comment;
 			if (value && webpackCommentRegExp.test(value)) {
@@ -4608,14 +4587,16 @@ class JavascriptParser extends Parser {
 						)
 					)) {
 						if (typeof val === "object" && val !== null) {
-							if (val.constructor.name === "RegExp") val = new RegExp(val);
-							else val = JSON.parse(JSON.stringify(val));
+							val =
+								val.constructor.name === "RegExp"
+									? new RegExp(val)
+									: JSON.parse(JSON.stringify(val));
 						}
 						options[key] = val;
 					}
-				} catch (e) {
-					const newErr = new Error(String(e.message));
-					newErr.stack = String(e.stack);
+				} catch (err) {
+					const newErr = new Error(String(err.message));
+					newErr.stack = String(err.stack);
 					Object.assign(newErr, { comment });
 					errors.push(newErr);
 				}
@@ -4665,9 +4646,9 @@ class JavascriptParser extends Parser {
 		let name;
 		if (info instanceof VariableInfo) {
 			name = info.freeName;
-			if (typeof name !== "string") return undefined;
+			if (typeof name !== "string") return;
 		} else if (typeof info !== "string") {
-			return undefined;
+			return;
 		} else {
 			name = info;
 		}
@@ -4687,8 +4668,7 @@ class JavascriptParser extends Parser {
 			this.extractMemberExpressionChain(expression);
 		switch (object.type) {
 			case "CallExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0)
-					return undefined;
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0) return;
 				let callee = object.callee;
 				let rootMembers = EMPTY_ARRAY;
 				if (callee.type === "MemberExpression") {
@@ -4696,9 +4676,9 @@ class JavascriptParser extends Parser {
 						this.extractMemberExpressionChain(callee));
 				}
 				const rootName = getRootName(callee);
-				if (!rootName) return undefined;
+				if (!rootName) return;
 				const result = this.getFreeInfoFromVariable(rootName);
-				if (!result) return undefined;
+				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
 				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
 				return {
@@ -4716,13 +4696,12 @@ class JavascriptParser extends Parser {
 			case "Identifier":
 			case "MetaProperty":
 			case "ThisExpression": {
-				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0)
-					return undefined;
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0) return;
 				const rootName = getRootName(object);
-				if (!rootName) return undefined;
+				if (!rootName) return;
 
 				const result = this.getFreeInfoFromVariable(rootName);
-				if (!result) return undefined;
+				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
 				return {
 					type: "expression",
@@ -4768,8 +4747,8 @@ class JavascriptParser extends Parser {
 		let threw = false;
 		try {
 			ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
-		} catch (e) {
-			error = e;
+		} catch (err) {
+			error = err;
 			threw = true;
 		}
 
@@ -4784,7 +4763,7 @@ class JavascriptParser extends Parser {
 			try {
 				ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
 				threw = false;
-			} catch (e) {
+			} catch (_err) {
 				// we use the error from first parse try
 				// so nothing to do here
 			}