webpack 5.89.0 → 5.90.1

package/lib/javascript/JavascriptParser.js

@@ -93,7 +93,9 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
 /** @typedef {{declaredScope: ScopeInfo, freeName: string | true, tagInfo: TagInfo | undefined}} VariableInfoInterface */
 /** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[] }} GetInfoResult */
+/** @typedef {Statement | ModuleDeclaration | Expression} StatementPathItem */
 
+/** @type {string[]} */
 const EMPTY_ARRAY = [];
 const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
 const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
@@ -422,15 +424,21 @@ class JavascriptParser extends Parser {
 		this.scope = undefined;
 		/** @type {ParserState} */
 		this.state = undefined;
+		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
+		/** @type {Set<number> | undefined} */
 		this.semicolons = undefined;
-		/** @type {(Statement | ModuleDeclaration | Expression)[]} */
+		/** @type {StatementPathItem[]} */
 		this.statementPath = undefined;
 		/** @type {Statement | ModuleDeclaration | Expression | undefined} */
 		this.prevStatement = undefined;
-		/** @type {WeakMap<Expression, Set<string>>} */
+		/** @type {WeakMap<Expression, Set<string>> | undefined} */
 		this.destructuringAssignmentProperties = undefined;
 		this.currentTagData = undefined;
+		this.magicCommentContext = vm.createContext(undefined, {
+			name: "Webpack Magic Comment Parser",
+			codeGeneration: { strings: false, wasm: false }
+		});
 		this._initializeEvaluating();
 	}
 
@@ -537,34 +545,39 @@ class JavascriptParser extends Parser {
 				let allowedRight;
 				if (expr.operator === "&&") {
 					const leftAsBool = left.asBool();
-					if (leftAsBool === false) return left.setRange(expr.range);
+					if (leftAsBool === false)
+						return left.setRange(/** @type {Range} */ (expr.range));
 					returnRight = leftAsBool === true;
 					allowedRight = false;
 				} else if (expr.operator === "||") {
 					const leftAsBool = left.asBool();
-					if (leftAsBool === true) return left.setRange(expr.range);
+					if (leftAsBool === true)
+						return left.setRange(/** @type {Range} */ (expr.range));
 					returnRight = leftAsBool === false;
 					allowedRight = true;
 				} else if (expr.operator === "??") {
 					const leftAsNullish = left.asNullish();
-					if (leftAsNullish === false) return left.setRange(expr.range);
+					if (leftAsNullish === false)
+						return left.setRange(/** @type {Range} */ (expr.range));
 					if (leftAsNullish !== true) return;
 					returnRight = true;
 				} else return;
 				const right = this.evaluateExpression(expr.right);
 				if (returnRight) {
 					if (left.couldHaveSideEffects()) right.setSideEffects();
-					return right.setRange(expr.range);
+					return right.setRange(/** @type {Range} */ (expr.range));
 				}
 
 				const asBool = right.asBool();
 
 				if (allowedRight === true && asBool === true) {
 					return new BasicEvaluatedExpression()
-						.setRange(expr.range)
+						.setRange(/** @type {Range} */ (expr.range))
 						.setTruthy();
 				} else if (allowedRight === false && asBool === false) {
-					return new BasicEvaluatedExpression().setRange(expr.range).setFalsy();
+					return new BasicEvaluatedExpression()
+						.setRange(/** @type {Range} */ (expr.range))
+						.setFalsy();
 				}
 			});
 
@@ -677,7 +690,18 @@ class JavascriptParser extends Parser {
 				const isAlwaysDifferent = (a, b) =>
 					(a === true && b === false) || (a === false && b === true);
 
+				/**
+				 * @param {BasicEvaluatedExpression} left left
+				 * @param {BasicEvaluatedExpression} right right
+				 * @param {BasicEvaluatedExpression} res res
+				 * @param {boolean} eql true for "===" and false for "!=="
+				 * @returns {BasicEvaluatedExpression | undefined} result
+				 */
 				const handleTemplateStringCompare = (left, right, res, eql) => {
+					/**
+					 * @param {BasicEvaluatedExpression[]} parts parts
+					 * @returns {string} value
+					 */
 					const getPrefix = parts => {
 						let value = "";
 						for (const p of parts) {
@@ -687,6 +711,10 @@ class JavascriptParser extends Parser {
 						}
 						return value;
 					};
+					/**
+					 * @param {BasicEvaluatedExpression[]} parts parts
+					 * @returns {string} value
+					 */
 					const getSuffix = parts => {
 						let value = "";
 						for (let i = parts.length - 1; i >= 0; i--) {
@@ -696,10 +724,18 @@ class JavascriptParser extends Parser {
 						}
 						return value;
 					};
-					const leftPrefix = getPrefix(left.parts);
-					const rightPrefix = getPrefix(right.parts);
-					const leftSuffix = getSuffix(left.parts);
-					const rightSuffix = getSuffix(right.parts);
+					const leftPrefix = getPrefix(
+						/** @type {BasicEvaluatedExpression[]} */ (left.parts)
+					);
+					const rightPrefix = getPrefix(
+						/** @type {BasicEvaluatedExpression[]} */ (right.parts)
+					);
+					const leftSuffix = getSuffix(
+						/** @type {BasicEvaluatedExpression[]} */ (left.parts)
+					);
+					const rightSuffix = getSuffix(
+						/** @type {BasicEvaluatedExpression[]} */ (right.parts)
+					);
 					const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
 					const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
 					const prefixMismatch =
@@ -790,7 +826,7 @@ class JavascriptParser extends Parser {
 					const left = this.evaluateExpression(expr.left);
 					const right = this.evaluateExpression(expr.right);
 					const res = new BasicEvaluatedExpression();
-					res.setRange(expr.range);
+					res.setRange(/** @type {Range} */ (expr.range));
 
 					const leftConst = left.isCompileTimeValue();
 					const rightConst = right.isCompileTimeValue();
@@ -825,9 +861,12 @@ class JavascriptParser extends Parser {
 					const res = new BasicEvaluatedExpression();
 					if (left.isString()) {
 						if (right.isString()) {
-							res.setString(left.string + right.string);
+							res.setString(
+								/** @type {string} */ (left.string) +
+									/** @type {string} */ (right.string)
+							);
 						} else if (right.isNumber()) {
-							res.setString(left.string + right.number);
+							res.setString(/** @type {string} */ (left.string) + right.number);
 						} else if (
 							right.isWrapped() &&
 							right.prefix &&
@@ -837,7 +876,10 @@ class JavascriptParser extends Parser {
 							// => ("leftPrefix" + inner + "postfix")
 							res.setWrapped(
 								new BasicEvaluatedExpression()
-									.setString(left.string + right.prefix.string)
+									.setString(
+										/** @type {string} */ (left.string) +
+											/** @type {string} */ (right.prefix.string)
+									)
 									.setRange(joinRanges(left.range, right.prefix.range)),
 								right.postfix,
 								right.wrappedInnerExpressions
@@ -857,7 +899,7 @@ class JavascriptParser extends Parser {
 						}
 					} else if (left.isNumber()) {
 						if (right.isString()) {
-							res.setString(left.number + right.string);
+							res.setString(left.number + /** @type {string} */ (right.string));
 						} else if (right.isNumber()) {
 							res.setNumber(left.number + right.number);
 						} else {
@@ -865,7 +907,10 @@ class JavascriptParser extends Parser {
 						}
 					} else if (left.isBigInt()) {
 						if (right.isBigInt()) {
-							res.setBigInt(left.bigint + right.bigint);
+							res.setBigInt(
+								/** @type {bigint} */ (left.bigint) +
+									/** @type {bigint} */ (right.bigint)
+							);
 						}
 					} else if (left.isWrapped()) {
 						if (left.postfix && left.postfix.isString() && right.isString()) {
@@ -874,8 +919,16 @@ class JavascriptParser extends Parser {
 							res.setWrapped(
 								left.prefix,
 								new BasicEvaluatedExpression()
-									.setString(left.postfix.string + right.string)
-									.setRange(joinRanges(left.postfix.range, right.range)),
+									.setString(
+										/** @type {string} */ (left.postfix.string) +
+											/** @type {string} */ (right.string)
+									)
+									.setRange(
+										joinRanges(
+											/** @type {Range} */ (left.postfix.range),
+											/** @type {Range} */ (right.range)
+										)
+									),
 								left.wrappedInnerExpressions
 							);
 						} else if (
@@ -888,8 +941,16 @@ class JavascriptParser extends Parser {
 							res.setWrapped(
 								left.prefix,
 								new BasicEvaluatedExpression()
-									.setString(left.postfix.string + right.number)
-									.setRange(joinRanges(left.postfix.range, right.range)),
+									.setString(
+										/** @type {string} */ (left.postfix.string) +
+											/** @type {number} */ (right.number)
+									)
+									.setRange(
+										joinRanges(
+											/** @type {Range} */ (left.postfix.range),
+											/** @type {Range} */ (right.range)
+										)
+									),
 								left.wrappedInnerExpressions
 							);
 						} else if (right.isString()) {
@@ -903,7 +964,7 @@ class JavascriptParser extends Parser {
 								left.prefix,
 								new BasicEvaluatedExpression()
 									.setString(right.number + "")
-									.setRange(right.range),
+									.setRange(/** @type {Range} */ (right.range)),
 								left.wrappedInnerExpressions
 							);
 						} else if (right.isWrapped()) {
@@ -953,7 +1014,7 @@ class JavascriptParser extends Parser {
 					}
 					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
 						res.setSideEffects();
-					res.setRange(expr.range);
+					res.setRange(/** @type {Range} */ (expr.range));
 					return res;
 				} else if (expr.operator === "-") {
 					return handleConstOperation((l, r) => l - r);
@@ -1057,7 +1118,7 @@ class JavascriptParser extends Parser {
 						case "FunctionExpression": {
 							return new BasicEvaluatedExpression()
 								.setString("function")
-								.setRange(expr.range);
+								.setRange(/** @type {Range} */ (expr.range));
 						}
 					}
 					const arg = this.evaluateExpression(expr.argument);
@@ -1065,44 +1126,44 @@ class JavascriptParser extends Parser {
 					if (arg.isString()) {
 						return new BasicEvaluatedExpression()
 							.setString("string")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isWrapped()) {
 						return new BasicEvaluatedExpression()
 							.setString("string")
 							.setSideEffects()
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isUndefined()) {
 						return new BasicEvaluatedExpression()
 							.setString("undefined")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isNumber()) {
 						return new BasicEvaluatedExpression()
 							.setString("number")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isBigInt()) {
 						return new BasicEvaluatedExpression()
 							.setString("bigint")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isBoolean()) {
 						return new BasicEvaluatedExpression()
 							.setString("boolean")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
 						return new BasicEvaluatedExpression()
 							.setString("object")
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 					if (arg.isArray()) {
 						return new BasicEvaluatedExpression()
 							.setString("object")
 							.setSideEffects(arg.couldHaveSideEffects())
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 				} else if (expr.operator === "!") {
 					const argument = this.evaluateExpression(expr.argument);
@@ -1111,7 +1172,7 @@ class JavascriptParser extends Parser {
 					return new BasicEvaluatedExpression()
 						.setBoolean(!bool)
 						.setSideEffects(argument.couldHaveSideEffects())
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				} else if (expr.operator === "~") {
 					return handleConstOperation(v => ~v);
 				} else if (expr.operator === "+") {
@@ -1123,13 +1184,13 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluateTypeof.for("undefined").tap("JavascriptParser", expr => {
 			return new BasicEvaluatedExpression()
 				.setString("undefined")
-				.setRange(expr.range);
+				.setRange(/** @type {Range} */ (expr.range));
 		});
 		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
 			if (/** @type {Identifier} */ (expr).name === "undefined") {
 				return new BasicEvaluatedExpression()
 					.setUndefined()
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
 		/**
@@ -1177,7 +1238,7 @@ class JavascriptParser extends Parser {
 								info.getMembersOptionals,
 								info.getMemberRanges
 							)
-							.setRange(expr.range);
+							.setRange(/** @type {Range} */ (expr.range));
 					}
 				});
 			this.hooks.finish.tap("JavascriptParser", () => {
@@ -1274,14 +1335,17 @@ class JavascriptParser extends Parser {
 					if (arg2.type === "SpreadElement") return;
 					const arg2Eval = this.evaluateExpression(arg2);
 					if (!arg2Eval.isNumber()) return;
-					result = param.string.indexOf(arg1Value, arg2Eval.number);
+					result = /** @type {string} */ (param.string).indexOf(
+						arg1Value,
+						arg2Eval.number
+					);
 				} else {
-					result = param.string.indexOf(arg1Value);
+					result = /** @type {string} */ (param.string).indexOf(arg1Value);
 				}
 				return new BasicEvaluatedExpression()
 					.setNumber(result)
 					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		this.hooks.evaluateCallExpressionMember
 			.for("replace")
@@ -1297,9 +1361,11 @@ class JavascriptParser extends Parser {
 				if (!arg2.isString()) return;
 				const arg2Value = arg2.string;
 				return new BasicEvaluatedExpression()
-					.setString(param.string.replace(arg1Value, arg2Value))
+					.setString(
+						/** @type {string} */ (param.string).replace(arg1Value, arg2Value)
+					)
 					.setSideEffects(param.couldHaveSideEffects())
-					.setRange(expr.range);
+					.setRange(/** @type {Range} */ (expr.range));
 			});
 		["substr", "substring", "slice"].forEach(fn => {
 			this.hooks.evaluateCallExpressionMember
@@ -1308,7 +1374,7 @@ class JavascriptParser extends Parser {
 					if (!param.isString()) return;
 					let arg1;
 					let result,
-						str = param.string;
+						str = /** @type {string} */ (param.string);
 					switch (expr.arguments.length) {
 						case 1:
 							if (expr.arguments[0].type === "SpreadElement") return;
@@ -1332,7 +1398,7 @@ class JavascriptParser extends Parser {
 					return new BasicEvaluatedExpression()
 						.setString(result)
 						.setSideEffects(param.couldHaveSideEffects())
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				});
 		});
 
@@ -1365,7 +1431,10 @@ class JavascriptParser extends Parser {
 						// is a const string
 
 						prevExpr.setString(prevExpr.string + exprAsString + quasi);
-						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
+						prevExpr.setRange([
+							/** @type {Range} */ (prevExpr.range)[0],
+							/** @type {Range} */ (quasiExpr.range)[1]
+						]);
 						// We unset the expression as it doesn't match to a single expression
 						prevExpr.setExpression(undefined);
 						continue;
@@ -1437,14 +1506,16 @@ class JavascriptParser extends Parser {
 						continue;
 					}
 
+					/** @type {string} */
 					const value = argExpr.isString()
-						? argExpr.string
-						: "" + argExpr.number;
+						? /** @type {string} */ (argExpr.string)
+						: "" + /** @type {number} */ (argExpr.number);
 
+					/** @type {string} */
 					const newString = value + (stringSuffix ? stringSuffix.string : "");
 					const newRange = /** @type {Range} */ ([
-						argExpr.range[0],
-						(stringSuffix || argExpr).range[1]
+						/** @type {Range} */ (argExpr.range)[0],
+						/** @type {Range} */ ((stringSuffix || argExpr).range)[1]
 					]);
 					stringSuffix = new BasicEvaluatedExpression()
 						.setString(newString)
@@ -1463,7 +1534,7 @@ class JavascriptParser extends Parser {
 							: innerExpressions.reverse();
 					return new BasicEvaluatedExpression()
 						.setWrapped(prefix, stringSuffix, inner)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				} else if (param.isWrapped()) {
 					const postfix = stringSuffix || param.postfix;
 					const inner = param.wrappedInnerExpressions
@@ -1471,17 +1542,18 @@ class JavascriptParser extends Parser {
 						: innerExpressions.reverse();
 					return new BasicEvaluatedExpression()
 						.setWrapped(param.prefix, postfix, inner)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				} else {
 					const newString =
-						param.string + (stringSuffix ? stringSuffix.string : "");
+						/** @type {string} */ (param.string) +
+						(stringSuffix ? stringSuffix.string : "");
 					return new BasicEvaluatedExpression()
 						.setString(newString)
 						.setSideEffects(
 							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
 								param.couldHaveSideEffects()
 						)
-						.setRange(expr.range);
+						.setRange(/** @type {Range} */ (expr.range));
 				}
 			});
 		this.hooks.evaluateCallExpressionMember
@@ -1493,9 +1565,11 @@ class JavascriptParser extends Parser {
 				let result;
 				const arg = this.evaluateExpression(expr.arguments[0]);
 				if (arg.isString()) {
-					result = param.string.split(arg.string);
+					result =
+						/** @type {string} */
+						(param.string).split(/** @type {string} */ (arg.string));
 				} else if (arg.isRegExp()) {
-					result = param.string.split(arg.regExp);
+					result = /** @type {string} */ (param.string).split(arg.regExp);
 				} else {
 					return;
 				}
@@ -2284,6 +2358,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {Declaration} declaration declaration
+	 * @param {TODO} onIdent on ident callback
+	 */
 	enterDeclaration(declaration, onIdent) {
 		switch (declaration.type) {
 			case "VariableDeclaration":
@@ -2540,10 +2618,16 @@ class JavascriptParser extends Parser {
 						declarator.init && this.getRenameIdentifier(declarator.init);
 					if (renameIdentifier && declarator.id.type === "Identifier") {
 						const hook = this.hooks.canRename.get(renameIdentifier);
-						if (hook !== undefined && hook.call(declarator.init)) {
+						if (
+							hook !== undefined &&
+							hook.call(/** @type {Expression} */ (declarator.init))
+						) {
 							// renaming with "var a = b;"
 							const hook = this.hooks.rename.get(renameIdentifier);
-							if (hook === undefined || !hook.call(declarator.init)) {
+							if (
+								hook === undefined ||
+								!hook.call(/** @type {Expression} */ (declarator.init))
+							) {
 								this.setVariable(declarator.id.name, renameIdentifier);
 							}
 							break;
@@ -2928,7 +3012,7 @@ class JavascriptParser extends Parser {
 			(currentStatement.type === "ExpressionStatement" &&
 				currentStatement.expression === expression)
 		) {
-			const old = this.statementPath.pop();
+			const old = /** @type {StatementPathItem} */ (this.statementPath.pop());
 			for (const expr of expression.expressions) {
 				this.statementPath.push(expr);
 				this.walkExpression(expr);
@@ -3383,6 +3467,13 @@ class JavascriptParser extends Parser {
 		if (expression.computed === true) this.walkExpression(expression.property);
 	}
 
+	/**
+	 * @param {TODO} expression member expression
+	 * @param {string} name name
+	 * @param {string | VariableInfo} rootInfo root info
+	 * @param {string[]} members members
+	 * @param {TODO} onUnhandled on unhandled callback
+	 */
 	walkMemberExpressionWithExpressionName(
 		expression,
 		name,
@@ -3436,7 +3527,14 @@ class JavascriptParser extends Parser {
 	walkMetaProperty(metaProperty) {
 		this.hooks.expression.for(getRootName(metaProperty)).call(metaProperty);
 	}
-
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {TODO} expr expression
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R | undefined} result of hook
+	 */
 	callHooksForExpression(hookMap, expr, ...args) {
 		return this.callHooksForExpressionWithFallback(
 			hookMap,
@@ -3725,6 +3823,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {(Pattern | Property)[]} patterns patterns
+	 * @param {TODO} onIdent on ident callback
+	 */
 	enterPatterns(patterns, onIdent) {
 		for (const pattern of patterns) {
 			if (typeof pattern !== "string") {
@@ -3735,6 +3837,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {Pattern | Property} pattern pattern
+	 * @param {TODO} onIdent on ident callback
+	 */
 	enterPattern(pattern, onIdent) {
 		if (!pattern) return;
 		switch (pattern.type) {
@@ -3759,7 +3865,7 @@ class JavascriptParser extends Parser {
 					this.enterIdentifier(pattern.value, onIdent);
 					this.scope.inShorthand = false;
 				} else {
-					this.enterPattern(pattern.value, onIdent);
+					this.enterPattern(/** @type {Identifier} */ (pattern.value), onIdent);
 				}
 				break;
 		}
@@ -3801,8 +3907,10 @@ class JavascriptParser extends Parser {
 			elementIndex++
 		) {
 			const element = pattern.elements[elementIndex];
-			// TODO check on `null`?
-			this.enterPattern(element, onIdent);
+
+			if (element) {
+				this.enterPattern(element, onIdent);
+			}
 		}
 	}
 
@@ -4041,7 +4149,10 @@ class JavascriptParser extends Parser {
 			case "ClassDeclaration":
 			case "ClassExpression": {
 				if (expr.body.type !== "ClassBody") return false;
-				if (expr.superClass && !this.isPure(expr.superClass, expr.range[0])) {
+				if (
+					expr.superClass &&
+					!this.isPure(expr.superClass, /** @type {Range} */ (expr.range)[0])
+				) {
 					return false;
 				}
 				const items =
@@ -4071,6 +4182,14 @@ class JavascriptParser extends Parser {
 						return false;
 					}
 
+					if (
+						expr.superClass &&
+						item.type === "MethodDefinition" &&
+						item.kind === "constructor"
+					) {
+						return false;
+					}
+
 					return true;
 				});
 			}
@@ -4143,15 +4262,26 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Range} range range
-	 * @returns {TODO[]} comments in the range
+	 * @returns {Comment[]} comments in the range
 	 */
 	getComments(range) {
 		const [rangeStart, rangeEnd] = range;
-		const compare = (comment, needle) => comment.range[0] - needle;
-		let idx = binarySearchBounds.ge(this.comments, rangeStart, compare);
+		/**
+		 * @param {Comment} comment comment
+		 * @param {number} needle needle
+		 * @returns {number} compared
+		 */
+		const compare = (comment, needle) =>
+			/** @type {Range} */ (comment.range)[0] - needle;
+		const comments = /** @type {Comment[]} */ (this.comments);
+		let idx = binarySearchBounds.ge(comments, rangeStart, compare);
+		/** @type {Comment[]} */
 		let commentsInRange = [];
-		while (this.comments[idx] && this.comments[idx].range[1] <= rangeEnd) {
-			commentsInRange.push(this.comments[idx]);
+		while (
+			comments[idx] &&
+			/** @type {Range} */ (comments[idx].range)[1] <= rangeEnd
+		) {
+			commentsInRange.push(comments[idx]);
 			idx++;
 		}
 
@@ -4167,14 +4297,17 @@ class JavascriptParser extends Parser {
 		if (currentStatement === undefined) throw new Error("Not in statement");
 		return (
 			// Either asking directly for the end position of the current statement
-			(currentStatement.range[1] === pos && this.semicolons.has(pos)) ||
+			(currentStatement.range[1] === pos &&
+				/** @type {Set<number>} */ (this.semicolons).has(pos)) ||
 			// Or asking for the start position of the current statement,
 			// here we have to check multiple things
 			(currentStatement.range[0] === pos &&
 				// is there a previous statement which might be relevant?
 				this.prevStatement !== undefined &&
 				// is the end position of the previous statement an ASI position?
-				this.semicolons.has(this.prevStatement.range[1]))
+				/** @type {Set<number>} */ (this.semicolons).has(
+					this.prevStatement.range[1]
+				))
 		);
 	}
 
@@ -4183,7 +4316,7 @@ class JavascriptParser extends Parser {
 	 * @returns {void}
 	 */
 	unsetAsiPosition(pos) {
-		this.semicolons.delete(pos);
+		/** @type {Set<number>} */ (this.semicolons).delete(pos);
 	}
 
 	/**
@@ -4199,6 +4332,11 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/**
+	 * @param {string} name name
+	 * @param {TODO} tag tag info
+	 * @returns {TODO} tag data
+	 */
 	getTagData(name, tag) {
 		const info = this.scope.definitions.get(name);
 		if (info instanceof VariableInfo) {
@@ -4210,6 +4348,11 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * @param {string} name name
+	 * @param {TODO} tag tag info
+	 * @param {TODO=} data data
+	 */
 	tagVariable(name, tag, data) {
 		const oldInfo = this.scope.definitions.get(name);
 		/** @type {VariableInfo} */
@@ -4326,7 +4469,10 @@ class JavascriptParser extends Parser {
 				// try compile only if webpack options comment is present
 				try {
 					for (let [key, val] of Object.entries(
-						vm.runInNewContext(`(function(){return {${value}};})()`)
+						vm.runInContext(
+							`(function(){return {${value}};})()`,
+							this.magicCommentContext
+						)
 					)) {
 						if (typeof val === "object" && val !== null) {
 							if (val.constructor.name === "RegExp") val = new RegExp(val);
@@ -4359,11 +4505,11 @@ class JavascriptParser extends Parser {
 			if (expr.computed) {
 				if (expr.property.type !== "Literal") break;
 				members.push(`${expr.property.value}`); // the literal
-				memberRanges.push(expr.object.range); // the range of the expression fragment before the literal
+				memberRanges.push(/** @type {Range} */ (expr.object.range)); // the range of the expression fragment before the literal
 			} else {
 				if (expr.property.type !== "Identifier") break;
 				members.push(expr.property.name); // the identifier
-				memberRanges.push(expr.object.range); // the range of the expression fragment before the identifier
+				memberRanges.push(/** @type {Range} */ (expr.object.range)); // the range of the expression fragment before the identifier
 			}
 			membersOptionals.push(expr.optional);
 			expr = expr.object;