webpack 5.99.6 → 5.99.7

package/lib/javascript/JavascriptParser.js

@@ -389,6 +389,8 @@ const EMPTY_COMMENT_OPTIONS = {
 	errors: null
 };
 
+const CLASS_NAME = "JavascriptParser";
+
 class JavascriptParser extends Parser {
 	/**
 	 * @param {"module" | "script" | "auto"} sourceType default source type
@@ -600,7 +602,7 @@ class JavascriptParser extends Parser {
 	}
 
 	_initializeEvaluating() {
-		this.hooks.evaluate.for("Literal").tap("JavascriptParser", _expr => {
+		this.hooks.evaluate.for("Literal").tap(CLASS_NAME, _expr => {
 			const expr = /** @type {Literal} */ (_expr);
 
 			switch (typeof expr.value) {
@@ -632,7 +634,7 @@ class JavascriptParser extends Parser {
 					.setRange(/** @type {Range} */ (expr.range));
 			}
 		});
-		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
+		this.hooks.evaluate.for("NewExpression").tap(CLASS_NAME, _expr => {
 			const expr = /** @type {NewExpression} */ (_expr);
 			const callee = expr.callee;
 			if (callee.type !== "Identifier") return;
@@ -695,52 +697,50 @@ class JavascriptParser extends Parser {
 				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
 				.setRange(/** @type {Range} */ (expr.range));
 		});
-		this.hooks.evaluate
-			.for("LogicalExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {LogicalExpression} */ (_expr);
-
-				const left = this.evaluateExpression(expr.left);
-				let returnRight = false;
-				/** @type {boolean | undefined} */
-				let allowedRight;
-				if (expr.operator === "&&") {
-					const leftAsBool = left.asBool();
-					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(/** @type {Range} */ (expr.range));
-					returnRight = leftAsBool === false;
-					allowedRight = true;
-				} else if (expr.operator === "??") {
-					const leftAsNullish = left.asNullish();
-					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(/** @type {Range} */ (expr.range));
-				}
+		this.hooks.evaluate.for("LogicalExpression").tap(CLASS_NAME, _expr => {
+			const expr = /** @type {LogicalExpression} */ (_expr);
+
+			const left = this.evaluateExpression(expr.left);
+			let returnRight = false;
+			/** @type {boolean | undefined} */
+			let allowedRight;
+			if (expr.operator === "&&") {
+				const leftAsBool = left.asBool();
+				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(/** @type {Range} */ (expr.range));
+				returnRight = leftAsBool === false;
+				allowedRight = true;
+			} else if (expr.operator === "??") {
+				const leftAsNullish = left.asNullish();
+				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(/** @type {Range} */ (expr.range));
+			}
 
-				const asBool = right.asBool();
+			const asBool = right.asBool();
 
-				if (allowedRight === true && asBool === true) {
-					return new BasicEvaluatedExpression()
-						.setRange(/** @type {Range} */ (expr.range))
-						.setTruthy();
-				} else if (allowedRight === false && asBool === false) {
-					return new BasicEvaluatedExpression()
-						.setRange(/** @type {Range} */ (expr.range))
-						.setFalsy();
-				}
-			});
+			if (allowedRight === true && asBool === true) {
+				return new BasicEvaluatedExpression()
+					.setRange(/** @type {Range} */ (expr.range))
+					.setTruthy();
+			} else if (allowedRight === false && asBool === false) {
+				return new BasicEvaluatedExpression()
+					.setRange(/** @type {Range} */ (expr.range))
+					.setFalsy();
+			}
+		});
 
 		/**
 		 * In simple logical cases, we can use valueAsExpression to assist us in evaluating the expression on
@@ -810,553 +810,539 @@ class JavascriptParser extends Parser {
 			}
 		};
 
-		this.hooks.evaluate
-			.for("BinaryExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {BinaryExpression} */ (_expr);
+		this.hooks.evaluate.for("BinaryExpression").tap(CLASS_NAME, _expr => {
+			const expr = /** @type {BinaryExpression} */ (_expr);
 
-				/**
-				 * 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
-				 */
-				const handleConstOperation = operandHandler => {
-					const left = this.evaluateExpression(expr.left);
-					if (!left.isCompileTimeValue()) return;
-
-					const right = this.evaluateExpression(expr.right);
-					if (!right.isCompileTimeValue()) return;
+			/**
+			 * 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
+			 */
+			const handleConstOperation = operandHandler => {
+				const left = this.evaluateExpression(expr.left);
+				if (!left.isCompileTimeValue()) return;
 
-					const result = operandHandler(
-						/** @type {T} */ (left.asCompileTimeValue()),
-						/** @type {T} */ (right.asCompileTimeValue())
-					);
-					return valueAsExpression(
-						result,
-						expr,
-						left.couldHaveSideEffects() || right.couldHaveSideEffects()
-					);
-				};
+				const right = this.evaluateExpression(expr.right);
+				if (!right.isCompileTimeValue()) return;
 
-				/**
-				 * 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
-				 */
-				const isAlwaysDifferent = (a, b) =>
-					(a === true && b === false) || (a === false && b === true);
+				const result = operandHandler(
+					/** @type {T} */ (left.asCompileTimeValue()),
+					/** @type {T} */ (right.asCompileTimeValue())
+				);
+				return valueAsExpression(
+					result,
+					expr,
+					left.couldHaveSideEffects() || right.couldHaveSideEffects()
+				);
+			};
 
+			/**
+			 * 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
+			 */
+			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} left left
-				 * @param {BasicEvaluatedExpression} right right
-				 * @param {BasicEvaluatedExpression} res res
-				 * @param {boolean} eql true for "===" and false for "!=="
-				 * @returns {BasicEvaluatedExpression | undefined} result
+				 * @param {BasicEvaluatedExpression[]} parts parts
+				 * @returns {string} value
 				 */
-				const handleTemplateStringCompare = (left, right, res, eql) => {
-					/**
-					 * @param {BasicEvaluatedExpression[]} parts parts
-					 * @returns {string} value
-					 */
-					const getPrefix = parts => {
-						let value = "";
-						for (const p of parts) {
-							const v = p.asString();
-							if (v !== undefined) value += v;
-							else break;
-						}
-						return value;
-					};
-					/**
-					 * @param {BasicEvaluatedExpression[]} parts parts
-					 * @returns {string} value
-					 */
-					const getSuffix = parts => {
-						let value = "";
-						for (let i = parts.length - 1; i >= 0; i--) {
-							const v = parts[i].asString();
-							if (v !== undefined) value = v + value;
-							else break;
-						}
-						return value;
-					};
-					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 =
-						lenPrefix > 0 &&
-						leftPrefix.slice(0, lenPrefix) !== rightPrefix.slice(0, lenPrefix);
-					const suffixMismatch =
-						lenSuffix > 0 &&
-						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix);
-					if (prefixMismatch || suffixMismatch) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
+				const getPrefix = parts => {
+					let value = "";
+					for (const p of parts) {
+						const v = p.asString();
+						if (v !== undefined) value += v;
+						else break;
 					}
+					return value;
 				};
-
 				/**
-				 * Helper function to handle BinaryExpressions using strict equality comparisons (e.g. "===" and "!==").
-				 * @param {boolean} eql true for "===" and false for "!=="
-				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+				 * @param {BasicEvaluatedExpression[]} parts parts
+				 * @returns {string} value
 				 */
-				const handleStrictEqualityComparison = eql => {
-					const left = this.evaluateExpression(expr.left);
-					const right = this.evaluateExpression(expr.right);
-					const res = new BasicEvaluatedExpression();
-					res.setRange(/** @type {Range} */ (expr.range));
-
-					const leftConst = left.isCompileTimeValue();
-					const rightConst = right.isCompileTimeValue();
-
-					if (leftConst && rightConst) {
-						return res
-							.setBoolean(
-								eql ===
-									(left.asCompileTimeValue() === right.asCompileTimeValue())
-							)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
+				const getSuffix = parts => {
+					let value = "";
+					for (let i = parts.length - 1; i >= 0; i--) {
+						const v = parts[i].asString();
+						if (v !== undefined) value = v + value;
+						else break;
 					}
+					return value;
+				};
+				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 =
+					lenPrefix > 0 &&
+					leftPrefix.slice(0, lenPrefix) !== rightPrefix.slice(0, lenPrefix);
+				const suffixMismatch =
+					lenSuffix > 0 &&
+					leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix);
+				if (prefixMismatch || suffixMismatch) {
+					return res
+						.setBoolean(!eql)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+			};
 
-					if (left.isArray() && right.isArray()) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-					if (left.isTemplateString() && right.isTemplateString()) {
-						return handleTemplateStringCompare(left, right, res, eql);
-					}
+			/**
+			 * Helper function to handle BinaryExpressions using strict equality comparisons (e.g. "===" and "!==").
+			 * @param {boolean} eql true for "===" and false for "!=="
+			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+			 */
+			const handleStrictEqualityComparison = eql => {
+				const left = this.evaluateExpression(expr.left);
+				const right = this.evaluateExpression(expr.right);
+				const res = new BasicEvaluatedExpression();
+				res.setRange(/** @type {Range} */ (expr.range));
 
-					const leftPrimitive = left.isPrimitiveType();
-					const rightPrimitive = right.isPrimitiveType();
+				const leftConst = left.isCompileTimeValue();
+				const rightConst = right.isCompileTimeValue();
 
-					if (
-						// Primitive !== Object or
-						// compile-time object types are never equal to something at runtime
-						(leftPrimitive === false &&
-							(leftConst || rightPrimitive === true)) ||
-						(rightPrimitive === false &&
-							(rightConst || leftPrimitive === true)) ||
-						// Different nullish or boolish status also means not equal
-						isAlwaysDifferent(
-							/** @type {boolean} */ (left.asBool()),
-							/** @type {boolean} */ (right.asBool())
-						) ||
-						isAlwaysDifferent(
-							/** @type {boolean} */ (left.asNullish()),
-							/** @type {boolean} */ (right.asNullish())
+				if (leftConst && rightConst) {
+					return res
+						.setBoolean(
+							eql === (left.asCompileTimeValue() === right.asCompileTimeValue())
 						)
-					) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-				};
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
 
-				/**
-				 * Helper function to handle BinaryExpressions using abstract equality comparisons (e.g. "==" and "!=").
-				 * @param {boolean} eql true for "==" and false for "!="
-				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
-				 */
-				const handleAbstractEqualityComparison = eql => {
-					const left = this.evaluateExpression(expr.left);
-					const right = this.evaluateExpression(expr.right);
-					const res = new BasicEvaluatedExpression();
-					res.setRange(/** @type {Range} */ (expr.range));
-
-					const leftConst = left.isCompileTimeValue();
-					const rightConst = right.isCompileTimeValue();
-
-					if (leftConst && rightConst) {
-						return res
-							.setBoolean(
-								eql ===
-									// eslint-disable-next-line eqeqeq
-									(left.asCompileTimeValue() == right.asCompileTimeValue())
-							)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
+				if (left.isArray() && right.isArray()) {
+					return res
+						.setBoolean(!eql)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+				if (left.isTemplateString() && right.isTemplateString()) {
+					return handleTemplateStringCompare(left, right, res, eql);
+				}
 
-					if (left.isArray() && right.isArray()) {
-						return res
-							.setBoolean(!eql)
-							.setSideEffects(
-								left.couldHaveSideEffects() || right.couldHaveSideEffects()
-							);
-					}
-					if (left.isTemplateString() && right.isTemplateString()) {
-						return handleTemplateStringCompare(left, right, res, eql);
-					}
-				};
+				const leftPrimitive = left.isPrimitiveType();
+				const rightPrimitive = right.isPrimitiveType();
 
-				if (expr.operator === "+") {
-					const left = this.evaluateExpression(expr.left);
-					const right = this.evaluateExpression(expr.right);
-					const res = new BasicEvaluatedExpression();
-					if (left.isString()) {
-						if (right.isString()) {
-							res.setString(
-								/** @type {string} */ (left.string) +
-									/** @type {string} */ (right.string)
-							);
-						} else if (right.isNumber()) {
-							res.setString(/** @type {string} */ (left.string) + right.number);
-						} else if (
-							right.isWrapped() &&
-							right.prefix &&
-							right.prefix.isString()
-						) {
-							// "left" + ("prefix" + inner + "postfix")
-							// => ("leftPrefix" + inner + "postfix")
-							res.setWrapped(
-								new BasicEvaluatedExpression()
-									.setString(
-										/** @type {string} */ (left.string) +
-											/** @type {string} */ (right.prefix.string)
-									)
-									.setRange(
-										joinRanges(
-											/** @type {Range} */ (left.range),
-											/** @type {Range} */ (right.prefix.range)
-										)
-									),
-								right.postfix,
-								right.wrappedInnerExpressions
-							);
-						} else if (right.isWrapped()) {
-							// "left" + ([null] + inner + "postfix")
-							// => ("left" + inner + "postfix")
-							res.setWrapped(
-								left,
-								right.postfix,
-								right.wrappedInnerExpressions
-							);
-						} else {
-							// "left" + expr
-							// => ("left" + expr + "")
-							res.setWrapped(left, null, [right]);
-						}
-					} else if (left.isNumber()) {
-						if (right.isString()) {
-							res.setString(left.number + /** @type {string} */ (right.string));
-						} else if (right.isNumber()) {
-							res.setNumber(
-								/** @type {number} */ (left.number) +
-									/** @type {number} */ (right.number)
-							);
-						} else {
-							return;
-						}
-					} else if (left.isBigInt()) {
-						if (right.isBigInt()) {
-							res.setBigInt(
-								/** @type {bigint} */ (left.bigint) +
-									/** @type {bigint} */ (right.bigint)
-							);
-						}
-					} else if (left.isWrapped()) {
-						if (left.postfix && left.postfix.isString() && right.isString()) {
-							// ("prefix" + inner + "postfix") + "right"
-							// => ("prefix" + inner + "postfixRight")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(
-										/** @type {string} */ (left.postfix.string) +
-											/** @type {string} */ (right.string)
+				if (
+					// Primitive !== Object or
+					// compile-time object types are never equal to something at runtime
+					(leftPrimitive === false && (leftConst || rightPrimitive === true)) ||
+					(rightPrimitive === false &&
+						(rightConst || leftPrimitive === true)) ||
+					// Different nullish or boolish status also means not equal
+					isAlwaysDifferent(
+						/** @type {boolean} */ (left.asBool()),
+						/** @type {boolean} */ (right.asBool())
+					) ||
+					isAlwaysDifferent(
+						/** @type {boolean} */ (left.asNullish()),
+						/** @type {boolean} */ (right.asNullish())
+					)
+				) {
+					return res
+						.setBoolean(!eql)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+			};
+
+			/**
+			 * Helper function to handle BinaryExpressions using abstract equality comparisons (e.g. "==" and "!=").
+			 * @param {boolean} eql true for "==" and false for "!="
+			 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+			 */
+			const handleAbstractEqualityComparison = eql => {
+				const left = this.evaluateExpression(expr.left);
+				const right = this.evaluateExpression(expr.right);
+				const res = new BasicEvaluatedExpression();
+				res.setRange(/** @type {Range} */ (expr.range));
+
+				const leftConst = left.isCompileTimeValue();
+				const rightConst = right.isCompileTimeValue();
+
+				if (leftConst && rightConst) {
+					return res
+						.setBoolean(
+							eql ===
+								// eslint-disable-next-line eqeqeq
+								(left.asCompileTimeValue() == right.asCompileTimeValue())
+						)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+
+				if (left.isArray() && right.isArray()) {
+					return res
+						.setBoolean(!eql)
+						.setSideEffects(
+							left.couldHaveSideEffects() || right.couldHaveSideEffects()
+						);
+				}
+				if (left.isTemplateString() && right.isTemplateString()) {
+					return handleTemplateStringCompare(left, right, res, eql);
+				}
+			};
+
+			if (expr.operator === "+") {
+				const left = this.evaluateExpression(expr.left);
+				const right = this.evaluateExpression(expr.right);
+				const res = new BasicEvaluatedExpression();
+				if (left.isString()) {
+					if (right.isString()) {
+						res.setString(
+							/** @type {string} */ (left.string) +
+								/** @type {string} */ (right.string)
+						);
+					} else if (right.isNumber()) {
+						res.setString(/** @type {string} */ (left.string) + right.number);
+					} else if (
+						right.isWrapped() &&
+						right.prefix &&
+						right.prefix.isString()
+					) {
+						// "left" + ("prefix" + inner + "postfix")
+						// => ("leftPrefix" + inner + "postfix")
+						res.setWrapped(
+							new BasicEvaluatedExpression()
+								.setString(
+									/** @type {string} */ (left.string) +
+										/** @type {string} */ (right.prefix.string)
+								)
+								.setRange(
+									joinRanges(
+										/** @type {Range} */ (left.range),
+										/** @type {Range} */ (right.prefix.range)
 									)
-									.setRange(
-										joinRanges(
-											/** @type {Range} */ (left.postfix.range),
-											/** @type {Range} */ (right.range)
-										)
-									),
-								left.wrappedInnerExpressions
-							);
-						} else if (
-							left.postfix &&
-							left.postfix.isString() &&
-							right.isNumber()
-						) {
-							// ("prefix" + inner + "postfix") + 123
-							// => ("prefix" + inner + "postfix123")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(
-										/** @type {string} */ (left.postfix.string) +
-											/** @type {number} */ (right.number)
+								),
+							right.postfix,
+							right.wrappedInnerExpressions
+						);
+					} else if (right.isWrapped()) {
+						// "left" + ([null] + inner + "postfix")
+						// => ("left" + inner + "postfix")
+						res.setWrapped(left, right.postfix, right.wrappedInnerExpressions);
+					} else {
+						// "left" + expr
+						// => ("left" + expr + "")
+						res.setWrapped(left, null, [right]);
+					}
+				} else if (left.isNumber()) {
+					if (right.isString()) {
+						res.setString(left.number + /** @type {string} */ (right.string));
+					} else if (right.isNumber()) {
+						res.setNumber(
+							/** @type {number} */ (left.number) +
+								/** @type {number} */ (right.number)
+						);
+					} else {
+						return;
+					}
+				} else if (left.isBigInt()) {
+					if (right.isBigInt()) {
+						res.setBigInt(
+							/** @type {bigint} */ (left.bigint) +
+								/** @type {bigint} */ (right.bigint)
+						);
+					}
+				} else if (left.isWrapped()) {
+					if (left.postfix && left.postfix.isString() && right.isString()) {
+						// ("prefix" + inner + "postfix") + "right"
+						// => ("prefix" + inner + "postfixRight")
+						res.setWrapped(
+							left.prefix,
+							new BasicEvaluatedExpression()
+								.setString(
+									/** @type {string} */ (left.postfix.string) +
+										/** @type {string} */ (right.string)
+								)
+								.setRange(
+									joinRanges(
+										/** @type {Range} */ (left.postfix.range),
+										/** @type {Range} */ (right.range)
 									)
-									.setRange(
-										joinRanges(
-											/** @type {Range} */ (left.postfix.range),
-											/** @type {Range} */ (right.range)
-										)
-									),
-								left.wrappedInnerExpressions
-							);
-						} else if (right.isString()) {
-							// ("prefix" + inner + [null]) + "right"
-							// => ("prefix" + inner + "right")
-							res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
-						} else if (right.isNumber()) {
-							// ("prefix" + inner + [null]) + 123
-							// => ("prefix" + inner + "123")
-							res.setWrapped(
-								left.prefix,
-								new BasicEvaluatedExpression()
-									.setString(String(right.number))
-									.setRange(/** @type {Range} */ (right.range)),
-								left.wrappedInnerExpressions
-							);
-						} else if (right.isWrapped()) {
-							// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
-							// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
-							res.setWrapped(
-								left.prefix,
-								right.postfix,
-								left.wrappedInnerExpressions &&
-									right.wrappedInnerExpressions &&
-									left.wrappedInnerExpressions
-										.concat(left.postfix ? [left.postfix] : [])
-										.concat(right.prefix ? [right.prefix] : [])
-										.concat(right.wrappedInnerExpressions)
-							);
-						} else {
-							// ("prefix" + inner + postfix) + expr
-							// => ("prefix" + inner + postfix + expr + [null])
-							res.setWrapped(
-								left.prefix,
-								null,
-								left.wrappedInnerExpressions &&
-									left.wrappedInnerExpressions.concat(
-										left.postfix ? [left.postfix, right] : [right]
+								),
+							left.wrappedInnerExpressions
+						);
+					} else if (
+						left.postfix &&
+						left.postfix.isString() &&
+						right.isNumber()
+					) {
+						// ("prefix" + inner + "postfix") + 123
+						// => ("prefix" + inner + "postfix123")
+						res.setWrapped(
+							left.prefix,
+							new BasicEvaluatedExpression()
+								.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()) {
-						// left + "right"
-						// => ([null] + left + "right")
-						res.setWrapped(null, right, [left]);
+						// ("prefix" + inner + [null]) + "right"
+						// => ("prefix" + inner + "right")
+						res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
+					} else if (right.isNumber()) {
+						// ("prefix" + inner + [null]) + 123
+						// => ("prefix" + inner + "123")
+						res.setWrapped(
+							left.prefix,
+							new BasicEvaluatedExpression()
+								.setString(String(right.number))
+								.setRange(/** @type {Range} */ (right.range)),
+							left.wrappedInnerExpressions
+						);
 					} else if (right.isWrapped()) {
-						// left + (prefix + inner + "postfix")
-						// => ([null] + left + prefix + inner + "postfix")
+						// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
+						// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
 						res.setWrapped(
-							null,
+							left.prefix,
 							right.postfix,
-							right.wrappedInnerExpressions &&
-								(right.prefix ? [left, right.prefix] : [left]).concat(
-									right.wrappedInnerExpressions
-								)
+							left.wrappedInnerExpressions &&
+								right.wrappedInnerExpressions &&
+								left.wrappedInnerExpressions
+									.concat(left.postfix ? [left.postfix] : [])
+									.concat(right.prefix ? [right.prefix] : [])
+									.concat(right.wrappedInnerExpressions)
 						);
 					} else {
-						return;
+						// ("prefix" + inner + postfix) + expr
+						// => ("prefix" + inner + postfix + expr + [null])
+						res.setWrapped(
+							left.prefix,
+							null,
+							left.wrappedInnerExpressions &&
+								left.wrappedInnerExpressions.concat(
+									left.postfix ? [left.postfix, right] : [right]
+								)
+						);
 					}
-					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
-						res.setSideEffects();
-					res.setRange(/** @type {Range} */ (expr.range));
-					return res;
-				} else if (expr.operator === "-") {
-					return handleConstOperation((l, r) => l - r);
-				} else if (expr.operator === "*") {
-					return handleConstOperation((l, r) => l * r);
-				} else if (expr.operator === "/") {
-					return handleConstOperation((l, r) => l / r);
-				} else if (expr.operator === "**") {
-					return handleConstOperation((l, r) => l ** r);
-				} else if (expr.operator === "===") {
-					return handleStrictEqualityComparison(true);
-				} else if (expr.operator === "==") {
-					return handleAbstractEqualityComparison(true);
-				} else if (expr.operator === "!==") {
-					return handleStrictEqualityComparison(false);
-				} else if (expr.operator === "!=") {
-					return handleAbstractEqualityComparison(false);
-				} else if (expr.operator === "&") {
-					return handleConstOperation((l, r) => l & r);
-				} else if (expr.operator === "|") {
-					return handleConstOperation((l, r) => l | r);
-				} else if (expr.operator === "^") {
-					return handleConstOperation((l, r) => l ^ r);
-				} else if (expr.operator === ">>>") {
-					return handleConstOperation((l, r) => l >>> r);
-				} else if (expr.operator === ">>") {
-					return handleConstOperation((l, r) => l >> r);
-				} else if (expr.operator === "<<") {
-					return handleConstOperation((l, r) => l << r);
-				} else if (expr.operator === "<") {
-					return handleConstOperation((l, r) => l < r);
-				} else if (expr.operator === ">") {
-					return handleConstOperation((l, r) => l > r);
-				} else if (expr.operator === "<=") {
-					return handleConstOperation((l, r) => l <= r);
-				} else if (expr.operator === ">=") {
-					return handleConstOperation((l, r) => l >= r);
-				}
-			});
-		this.hooks.evaluate
-			.for("UnaryExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {UnaryExpression} */ (_expr);
-
-				/**
-				 * 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
-				 */
-				const handleConstOperation = operandHandler => {
-					const argument = this.evaluateExpression(expr.argument);
-					if (!argument.isCompileTimeValue()) return;
-					const result = operandHandler(
-						/** @type {T} */ (argument.asCompileTimeValue())
-					);
-					return valueAsExpression(
-						result,
-						expr,
-						argument.couldHaveSideEffects()
+				} 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;
+				}
+				if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
+					res.setSideEffects();
+				res.setRange(/** @type {Range} */ (expr.range));
+				return res;
+			} else if (expr.operator === "-") {
+				return handleConstOperation((l, r) => l - r);
+			} else if (expr.operator === "*") {
+				return handleConstOperation((l, r) => l * r);
+			} else if (expr.operator === "/") {
+				return handleConstOperation((l, r) => l / r);
+			} else if (expr.operator === "**") {
+				return handleConstOperation((l, r) => l ** r);
+			} else if (expr.operator === "===") {
+				return handleStrictEqualityComparison(true);
+			} else if (expr.operator === "==") {
+				return handleAbstractEqualityComparison(true);
+			} else if (expr.operator === "!==") {
+				return handleStrictEqualityComparison(false);
+			} else if (expr.operator === "!=") {
+				return handleAbstractEqualityComparison(false);
+			} else if (expr.operator === "&") {
+				return handleConstOperation((l, r) => l & r);
+			} else if (expr.operator === "|") {
+				return handleConstOperation((l, r) => l | r);
+			} else if (expr.operator === "^") {
+				return handleConstOperation((l, r) => l ^ r);
+			} else if (expr.operator === ">>>") {
+				return handleConstOperation((l, r) => l >>> r);
+			} else if (expr.operator === ">>") {
+				return handleConstOperation((l, r) => l >> r);
+			} else if (expr.operator === "<<") {
+				return handleConstOperation((l, r) => l << r);
+			} else if (expr.operator === "<") {
+				return handleConstOperation((l, r) => l < r);
+			} else if (expr.operator === ">") {
+				return handleConstOperation((l, r) => l > r);
+			} else if (expr.operator === "<=") {
+				return handleConstOperation((l, r) => l <= r);
+			} else if (expr.operator === ">=") {
+				return handleConstOperation((l, r) => l >= r);
+			}
+		});
+		this.hooks.evaluate.for("UnaryExpression").tap(CLASS_NAME, _expr => {
+			const expr = /** @type {UnaryExpression} */ (_expr);
+
+			/**
+			 * 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
+			 */
+			const handleConstOperation = operandHandler => {
+				const argument = this.evaluateExpression(expr.argument);
+				if (!argument.isCompileTimeValue()) return;
+				const result = operandHandler(
+					/** @type {T} */ (argument.asCompileTimeValue())
+				);
+				return valueAsExpression(result, expr, argument.couldHaveSideEffects());
+			};
 
-				if (expr.operator === "typeof") {
-					switch (expr.argument.type) {
-						case "Identifier": {
-							const res = this.callHooksForName(
-								this.hooks.evaluateTypeof,
-								expr.argument.name,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "MetaProperty": {
-							const res = this.callHooksForName(
-								this.hooks.evaluateTypeof,
-								/** @type {string} */
-								(getRootName(expr.argument)),
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "MemberExpression": {
-							const res = this.callHooksForExpression(
-								this.hooks.evaluateTypeof,
-								expr.argument,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "ChainExpression": {
-							const res = this.callHooksForExpression(
-								this.hooks.evaluateTypeof,
-								expr.argument.expression,
-								expr
-							);
-							if (res !== undefined) return res;
-							break;
-						}
-						case "FunctionExpression": {
-							return new BasicEvaluatedExpression()
-								.setString("function")
-								.setRange(/** @type {Range} */ (expr.range));
-						}
-					}
-					const arg = this.evaluateExpression(expr.argument);
-					if (arg.isUnknown()) return;
-					if (arg.isString()) {
-						return new BasicEvaluatedExpression()
-							.setString("string")
-							.setRange(/** @type {Range} */ (expr.range));
-					}
-					if (arg.isWrapped()) {
-						return new BasicEvaluatedExpression()
-							.setString("string")
-							.setSideEffects()
-							.setRange(/** @type {Range} */ (expr.range));
-					}
-					if (arg.isUndefined()) {
-						return new BasicEvaluatedExpression()
-							.setString("undefined")
-							.setRange(/** @type {Range} */ (expr.range));
-					}
-					if (arg.isNumber()) {
-						return new BasicEvaluatedExpression()
-							.setString("number")
-							.setRange(/** @type {Range} */ (expr.range));
+			if (expr.operator === "typeof") {
+				switch (expr.argument.type) {
+					case "Identifier": {
+						const res = this.callHooksForName(
+							this.hooks.evaluateTypeof,
+							expr.argument.name,
+							expr
+						);
+						if (res !== undefined) return res;
+						break;
 					}
-					if (arg.isBigInt()) {
-						return new BasicEvaluatedExpression()
-							.setString("bigint")
-							.setRange(/** @type {Range} */ (expr.range));
+					case "MetaProperty": {
+						const res = this.callHooksForName(
+							this.hooks.evaluateTypeof,
+							/** @type {string} */
+							(getRootName(expr.argument)),
+							expr
+						);
+						if (res !== undefined) return res;
+						break;
 					}
-					if (arg.isBoolean()) {
-						return new BasicEvaluatedExpression()
-							.setString("boolean")
-							.setRange(/** @type {Range} */ (expr.range));
+					case "MemberExpression": {
+						const res = this.callHooksForExpression(
+							this.hooks.evaluateTypeof,
+							expr.argument,
+							expr
+						);
+						if (res !== undefined) return res;
+						break;
 					}
-					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
-						return new BasicEvaluatedExpression()
-							.setString("object")
-							.setRange(/** @type {Range} */ (expr.range));
+					case "ChainExpression": {
+						const res = this.callHooksForExpression(
+							this.hooks.evaluateTypeof,
+							expr.argument.expression,
+							expr
+						);
+						if (res !== undefined) return res;
+						break;
 					}
-					if (arg.isArray()) {
+					case "FunctionExpression": {
 						return new BasicEvaluatedExpression()
-							.setString("object")
-							.setSideEffects(arg.couldHaveSideEffects())
+							.setString("function")
 							.setRange(/** @type {Range} */ (expr.range));
 					}
-				} else if (expr.operator === "!") {
-					const argument = this.evaluateExpression(expr.argument);
-					const bool = argument.asBool();
-					if (typeof bool !== "boolean") return;
+				}
+				const arg = this.evaluateExpression(expr.argument);
+				if (arg.isUnknown()) return;
+				if (arg.isString()) {
 					return new BasicEvaluatedExpression()
-						.setBoolean(!bool)
-						.setSideEffects(argument.couldHaveSideEffects())
+						.setString("string")
 						.setRange(/** @type {Range} */ (expr.range));
-				} 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);
 				}
-			});
+				if (arg.isWrapped()) {
+					return new BasicEvaluatedExpression()
+						.setString("string")
+						.setSideEffects()
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isUndefined()) {
+					return new BasicEvaluatedExpression()
+						.setString("undefined")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isNumber()) {
+					return new BasicEvaluatedExpression()
+						.setString("number")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isBigInt()) {
+					return new BasicEvaluatedExpression()
+						.setString("bigint")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isBoolean()) {
+					return new BasicEvaluatedExpression()
+						.setString("boolean")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
+					return new BasicEvaluatedExpression()
+						.setString("object")
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+				if (arg.isArray()) {
+					return new BasicEvaluatedExpression()
+						.setString("object")
+						.setSideEffects(arg.couldHaveSideEffects())
+						.setRange(/** @type {Range} */ (expr.range));
+				}
+			} else if (expr.operator === "!") {
+				const argument = this.evaluateExpression(expr.argument);
+				const bool = argument.asBool();
+				if (typeof bool !== "boolean") return;
+				return new BasicEvaluatedExpression()
+					.setBoolean(!bool)
+					.setSideEffects(argument.couldHaveSideEffects())
+					.setRange(/** @type {Range} */ (expr.range));
+			} 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 =>
+			.tap(CLASS_NAME, expr =>
 				new BasicEvaluatedExpression()
 					.setString("undefined")
 					.setRange(/** @type {Range} */ (expr.range))
 			);
-		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
+		this.hooks.evaluate.for("Identifier").tap(CLASS_NAME, expr => {
 			if (/** @type {Identifier} */ (expr).name === "undefined") {
 				return new BasicEvaluatedExpression()
 					.setUndefined()
@@ -1373,7 +1359,7 @@ class JavascriptParser extends Parser {
 			let cachedExpression;
 			/** @type {GetInfoResult | undefined} */
 			let cachedInfo;
-			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
+			this.hooks.evaluate.for(exprType).tap(CLASS_NAME, expr => {
 				const expression =
 					/** @type {Identifier | ThisExpression | MemberExpression} */ (expr);
 
@@ -1398,7 +1384,7 @@ class JavascriptParser extends Parser {
 			});
 			this.hooks.evaluate
 				.for(exprType)
-				.tap({ name: "JavascriptParser", stage: 100 }, expr => {
+				.tap({ name: CLASS_NAME, stage: 100 }, expr => {
 					const expression =
 						/** @type {Identifier | ThisExpression | MemberExpression} */
 						(expr);
@@ -1416,7 +1402,7 @@ class JavascriptParser extends Parser {
 							.setRange(/** @type {Range} */ (expression.range));
 					}
 				});
-			this.hooks.finish.tap("JavascriptParser", () => {
+			this.hooks.finish.tap(CLASS_NAME, () => {
 				// Cleanup for GC
 				cachedExpression = cachedInfo = undefined;
 			});
@@ -1451,7 +1437,7 @@ class JavascriptParser extends Parser {
 				};
 			}
 		});
-		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
+		this.hooks.evaluate.for("MetaProperty").tap(CLASS_NAME, expr => {
 			const metaProperty = /** @type {MetaProperty} */ (expr);
 
 			return this.callHooksForName(
@@ -1468,7 +1454,7 @@ class JavascriptParser extends Parser {
 			)
 		);
 
-		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
+		this.hooks.evaluate.for("CallExpression").tap(CLASS_NAME, _expr => {
 			const expr = /** @type {CallExpression} */ (_expr);
 			if (
 				expr.callee.type === "MemberExpression" &&
@@ -1497,7 +1483,7 @@ class JavascriptParser extends Parser {
 		});
 		this.hooks.evaluateCallExpressionMember
 			.for("indexOf")
-			.tap("JavascriptParser", (expr, param) => {
+			.tap(CLASS_NAME, (expr, param) => {
 				if (!param.isString()) return;
 				if (expr.arguments.length === 0) return;
 				const [arg1, arg2] = expr.arguments;
@@ -1525,7 +1511,7 @@ class JavascriptParser extends Parser {
 			});
 		this.hooks.evaluateCallExpressionMember
 			.for("replace")
-			.tap("JavascriptParser", (expr, param) => {
+			.tap(CLASS_NAME, (expr, param) => {
 				if (!param.isString()) return;
 				if (expr.arguments.length !== 2) return;
 				if (expr.arguments[0].type === "SpreadElement") return;
@@ -1548,7 +1534,7 @@ class JavascriptParser extends Parser {
 		for (const fn of ["substr", "substring", "slice"]) {
 			this.hooks.evaluateCallExpressionMember
 				.for(fn)
-				.tap("JavascriptParser", (expr, param) => {
+				.tap(CLASS_NAME, (expr, param) => {
 					if (!param.isString()) return;
 					let arg1;
 					let result;
@@ -1640,22 +1626,20 @@ class JavascriptParser extends Parser {
 			};
 		};
 
-		this.hooks.evaluate
-			.for("TemplateLiteral")
-			.tap("JavascriptParser", _node => {
-				const node = /** @type {TemplateLiteral} */ (_node);
+		this.hooks.evaluate.for("TemplateLiteral").tap(CLASS_NAME, _node => {
+			const node = /** @type {TemplateLiteral} */ (_node);
 
-				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
-				if (parts.length === 1) {
-					return parts[0].setRange(/** @type {Range} */ (node.range));
-				}
-				return new BasicEvaluatedExpression()
-					.setTemplateString(quasis, parts, "cooked")
-					.setRange(/** @type {Range} */ (node.range));
-			});
+			const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
+			if (parts.length === 1) {
+				return parts[0].setRange(/** @type {Range} */ (node.range));
+			}
+			return new BasicEvaluatedExpression()
+				.setTemplateString(quasis, parts, "cooked")
+				.setRange(/** @type {Range} */ (node.range));
+		});
 		this.hooks.evaluate
 			.for("TaggedTemplateExpression")
-			.tap("JavascriptParser", _node => {
+			.tap(CLASS_NAME, _node => {
 				const node = /** @type {TaggedTemplateExpression} */ (_node);
 				const tag = this.evaluateExpression(node.tag);
 
@@ -1672,7 +1656,7 @@ class JavascriptParser extends Parser {
 
 		this.hooks.evaluateCallExpressionMember
 			.for("concat")
-			.tap("JavascriptParser", (expr, param) => {
+			.tap(CLASS_NAME, (expr, param) => {
 				if (!param.isString() && !param.isWrapped()) return;
 				let stringSuffix = null;
 				let hasUnknownParams = false;
@@ -1742,7 +1726,7 @@ class JavascriptParser extends Parser {
 			});
 		this.hooks.evaluateCallExpressionMember
 			.for("split")
-			.tap("JavascriptParser", (expr, param) => {
+			.tap(CLASS_NAME, (expr, param) => {
 				if (!param.isString()) return;
 				if (expr.arguments.length !== 1) return;
 				if (expr.arguments[0].type === "SpreadElement") return;
@@ -1764,101 +1748,95 @@ class JavascriptParser extends Parser {
 					.setSideEffects(param.couldHaveSideEffects())
 					.setRange(/** @type {Range} */ (expr.range));
 			});
-		this.hooks.evaluate
-			.for("ConditionalExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ConditionalExpression} */ (_expr);
-
-				const condition = this.evaluateExpression(expr.test);
-				const conditionValue = condition.asBool();
-				let res;
-				if (conditionValue === undefined) {
-					const consequent = this.evaluateExpression(expr.consequent);
-					const alternate = this.evaluateExpression(expr.alternate);
-					res = new BasicEvaluatedExpression();
-					if (consequent.isConditional()) {
-						res.setOptions(
-							/** @type {BasicEvaluatedExpression[]} */ (consequent.options)
-						);
-					} else {
-						res.setOptions([consequent]);
-					}
-					if (alternate.isConditional()) {
-						res.addOptions(
-							/** @type {BasicEvaluatedExpression[]} */ (alternate.options)
-						);
-					} else {
-						res.addOptions([alternate]);
-					}
+		this.hooks.evaluate.for("ConditionalExpression").tap(CLASS_NAME, _expr => {
+			const expr = /** @type {ConditionalExpression} */ (_expr);
+
+			const condition = this.evaluateExpression(expr.test);
+			const conditionValue = condition.asBool();
+			let res;
+			if (conditionValue === undefined) {
+				const consequent = this.evaluateExpression(expr.consequent);
+				const alternate = this.evaluateExpression(expr.alternate);
+				res = new BasicEvaluatedExpression();
+				if (consequent.isConditional()) {
+					res.setOptions(
+						/** @type {BasicEvaluatedExpression[]} */ (consequent.options)
+					);
 				} else {
-					res = this.evaluateExpression(
-						conditionValue ? expr.consequent : expr.alternate
+					res.setOptions([consequent]);
+				}
+				if (alternate.isConditional()) {
+					res.addOptions(
+						/** @type {BasicEvaluatedExpression[]} */ (alternate.options)
 					);
-					if (condition.couldHaveSideEffects()) res.setSideEffects();
+				} else {
+					res.addOptions([alternate]);
 				}
-				res.setRange(/** @type {Range} */ (expr.range));
-				return res;
-			});
-		this.hooks.evaluate
-			.for("ArrayExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ArrayExpression} */ (_expr);
-
-				const items = expr.elements.map(
-					element =>
-						element !== null &&
-						element.type !== "SpreadElement" &&
-						this.evaluateExpression(element)
+			} else {
+				res = this.evaluateExpression(
+					conditionValue ? expr.consequent : expr.alternate
 				);
-				if (!items.every(Boolean)) return;
-				return new BasicEvaluatedExpression()
-					.setItems(/** @type {BasicEvaluatedExpression[]} */ (items))
-					.setRange(/** @type {Range} */ (expr.range));
-			});
-		this.hooks.evaluate
-			.for("ChainExpression")
-			.tap("JavascriptParser", _expr => {
-				const expr = /** @type {ChainExpression} */ (_expr);
-				/** @type {Expression[]} */
-				const optionalExpressionsStack = [];
-				/** @type {Expression|Super} */
-				let next = expr.expression;
-
-				while (
-					next.type === "MemberExpression" ||
-					next.type === "CallExpression"
-				) {
-					if (next.type === "MemberExpression") {
-						if (next.optional) {
-							// SuperNode can not be optional
-							optionalExpressionsStack.push(
-								/** @type {Expression} */ (next.object)
-							);
-						}
-						next = next.object;
-					} else {
-						if (next.optional) {
-							// SuperNode can not be optional
-							optionalExpressionsStack.push(
-								/** @type {Expression} */ (next.callee)
-							);
-						}
-						next = next.callee;
+				if (condition.couldHaveSideEffects()) res.setSideEffects();
+			}
+			res.setRange(/** @type {Range} */ (expr.range));
+			return res;
+		});
+		this.hooks.evaluate.for("ArrayExpression").tap(CLASS_NAME, _expr => {
+			const expr = /** @type {ArrayExpression} */ (_expr);
+
+			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))
+				.setRange(/** @type {Range} */ (expr.range));
+		});
+		this.hooks.evaluate.for("ChainExpression").tap(CLASS_NAME, _expr => {
+			const expr = /** @type {ChainExpression} */ (_expr);
+			/** @type {Expression[]} */
+			const optionalExpressionsStack = [];
+			/** @type {Expression|Super} */
+			let next = expr.expression;
+
+			while (
+				next.type === "MemberExpression" ||
+				next.type === "CallExpression"
+			) {
+				if (next.type === "MemberExpression") {
+					if (next.optional) {
+						// SuperNode can not be optional
+						optionalExpressionsStack.push(
+							/** @type {Expression} */ (next.object)
+						);
+					}
+					next = next.object;
+				} else {
+					if (next.optional) {
+						// SuperNode can not be optional
+						optionalExpressionsStack.push(
+							/** @type {Expression} */ (next.callee)
+						);
 					}
+					next = next.callee;
 				}
+			}
 
-				while (optionalExpressionsStack.length > 0) {
-					const expression =
-						/** @type {Expression} */
-						(optionalExpressionsStack.pop());
-					const evaluated = this.evaluateExpression(expression);
+			while (optionalExpressionsStack.length > 0) {
+				const expression =
+					/** @type {Expression} */
+					(optionalExpressionsStack.pop());
+				const evaluated = this.evaluateExpression(expression);
 
-					if (evaluated.asNullish()) {
-						return evaluated.setRange(/** @type {Range} */ (_expr.range));
-					}
+				if (evaluated.asNullish()) {
+					return evaluated.setRange(/** @type {Range} */ (_expr.range));
 				}
-				return this.evaluateExpression(expr.expression);
-			});
+			}
+			return this.evaluateExpression(expr.expression);
+		});
 	}
 
 	/**