webpack 5.99.8 → 5.100.0

package/lib/javascript/JavascriptParser.js

@@ -5,15 +5,16 @@
 
 "use strict";
 
-const { Parser: AcornParser, tokTypes } = require("acorn");
-const { SyncBailHook, HookMap } = require("tapable");
 const vm = require("vm");
+const { Parser: AcornParser, tokTypes } = require("acorn");
+const acornImportPhases = require("acorn-import-phases");
+const { HookMap, SyncBailHook } = require("tapable");
 const Parser = require("../Parser");
 const StackedMap = require("../util/StackedMap");
 const binarySearchBounds = require("../util/binarySearchBounds");
 const {
-	webpackCommentRegExp,
-	createMagicCommentContext
+	createMagicCommentContext,
+	webpackCommentRegExp
 } = require("../util/magicComment");
 const memoize = require("../util/memoize");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
@@ -83,6 +84,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */
 /** @typedef {import("estree").Super} Super */
+/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */
 /** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression */
 /** @typedef {import("estree").TemplateLiteral} TemplateLiteral */
 /** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
@@ -102,10 +104,10 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 // TODO remove cast when @types/estree has been updated to import assertions
 /** @typedef {import("estree").BaseNode & { type: "ImportAttribute", key: Identifier | Literal, value: Literal }} ImportAttribute */
-/** @typedef {import("estree").ImportDeclaration & { attributes?: Array<ImportAttribute> }} ImportDeclaration */
+/** @typedef {import("estree").ImportDeclaration & { attributes?: Array<ImportAttribute>, phase?: "defer" }} ImportDeclaration */
 /** @typedef {import("estree").ExportNamedDeclaration & { attributes?: Array<ImportAttribute> }} ExportNamedDeclaration */
 /** @typedef {import("estree").ExportAllDeclaration & { attributes?: Array<ImportAttribute> }} ExportAllDeclaration */
-/** @typedef {import("estree").ImportExpression & { options?: Expression | null }} ImportExpression */
+/** @typedef {import("estree").ImportExpression & { options?: Expression | null, phase?: "defer" }} ImportExpression */
 /** @typedef {ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration} ModuleDeclaration */
 
 /** @type {string[]} */
@@ -120,7 +122,7 @@ const LEGACY_ASSERT_ATTRIBUTES = Symbol("assert");
 const importAssertions = Parser =>
 	class extends Parser {
 		/**
-		 * @this {TODO}
+		 * @this {InstanceType<AcornParser>}
 		 * @returns {ImportAttribute[]} import attributes
 		 */
 		parseWithClause() {
@@ -180,7 +182,10 @@ const importAssertions = Parser =>
 	};
 
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
-const parser = AcornParser.extend(importAssertions);
+const parser = AcornParser.extend(
+	importAssertions,
+	acornImportPhases({ source: false })
+);
 
 /** @typedef {Record<string, string> & { _isLegacyAssert?: boolean }} ImportAttributes */
 
@@ -484,13 +489,15 @@ class JavascriptParser extends Parser {
 			preDeclarator: new SyncBailHook(["declarator", "statement"]),
 			/** @type {SyncBailHook<[VariableDeclarator, Statement], boolean | void>} */
 			declarator: new SyncBailHook(["declarator", "statement"]),
-			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclaration: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[Declaration], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
+			varDeclarationUsing: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
 			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
@@ -578,7 +585,9 @@ class JavascriptParser extends Parser {
 			/** @type {SyncBailHook<[ThrowStatement | ReturnStatement], boolean | void>} */
 			terminate: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
-			finish: new SyncBailHook(["ast", "comments"])
+			finish: new SyncBailHook(["ast", "comments"]),
+			/** @type {SyncBailHook<[Statement], boolean | void>} */
+			unusedStatement: new SyncBailHook(["statement"])
 		});
 		this.sourceType = sourceType;
 		/** @type {ScopeInfo} */
@@ -647,8 +656,9 @@ class JavascriptParser extends Parser {
 			} else if (
 				expr.arguments.length > 2 ||
 				this.getVariableInfo("RegExp") !== "RegExp"
-			)
+			) {
 				return;
+			}
 
 			let regExp;
 			const arg1 = expr.arguments[0];
@@ -688,8 +698,9 @@ class JavascriptParser extends Parser {
 					if (
 						flags === undefined ||
 						!BasicEvaluatedExpression.isValidRegExpFlags(flags)
-					)
+					) {
 						return;
+					}
 				}
 			}
 
@@ -706,23 +717,28 @@ class JavascriptParser extends Parser {
 			let allowedRight;
 			if (expr.operator === "&&") {
 				const leftAsBool = left.asBool();
-				if (leftAsBool === false)
+				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)
+				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)
+				if (leftAsNullish === false) {
 					return left.setRange(/** @type {Range} */ (expr.range));
+				}
 				if (leftAsNullish !== true) return;
 				returnRight = true;
-			} else return;
+			} else {
+				return;
+			}
 			const right = this.evaluateExpression(expr.right);
 			if (returnRight) {
 				if (left.couldHaveSideEffects()) right.setSideEffects();
@@ -1133,11 +1149,12 @@ class JavascriptParser extends Parser {
 							left.prefix,
 							right.postfix,
 							left.wrappedInnerExpressions &&
-								right.wrappedInnerExpressions &&
-								left.wrappedInnerExpressions
-									.concat(left.postfix ? [left.postfix] : [])
-									.concat(right.prefix ? [right.prefix] : [])
-									.concat(right.wrappedInnerExpressions)
+								right.wrappedInnerExpressions && [
+									...left.wrappedInnerExpressions,
+									...(left.postfix ? [left.postfix] : []),
+									...(right.prefix ? [right.prefix] : []),
+									...right.wrappedInnerExpressions
+								]
 						);
 					} else {
 						// ("prefix" + inner + postfix) + expr
@@ -1145,10 +1162,10 @@ class JavascriptParser extends Parser {
 						res.setWrapped(
 							left.prefix,
 							null,
-							left.wrappedInnerExpressions &&
-								left.wrappedInnerExpressions.concat(
-									left.postfix ? [left.postfix, right] : [right]
-								)
+							left.wrappedInnerExpressions && [
+								...left.wrappedInnerExpressions,
+								...(left.postfix ? [left.postfix, right] : [right])
+							]
 						);
 					}
 				} else if (right.isString()) {
@@ -1161,16 +1178,17 @@ class JavascriptParser extends Parser {
 					res.setWrapped(
 						null,
 						right.postfix,
-						right.wrappedInnerExpressions &&
-							(right.prefix ? [left, right.prefix] : [left]).concat(
-								right.wrappedInnerExpressions
-							)
+						right.wrappedInnerExpressions && [
+							...(right.prefix ? [left, right.prefix] : [left]),
+							...right.wrappedInnerExpressions
+						]
 					);
 				} else {
 					return;
 				}
-				if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
+				if (left.couldHaveSideEffects() || right.couldHaveSideEffects()) {
 					res.setSideEffects();
+				}
 				res.setRange(/** @type {Range} */ (expr.range));
 				return res;
 			} else if (expr.operator === "-") {
@@ -1368,9 +1386,10 @@ class JavascriptParser extends Parser {
 					return this.callHooksForInfoWithFallback(
 						this.hooks.evaluateIdentifier,
 						info.name,
-						name => {
+						_name => {
 							cachedExpression = expression;
 							cachedInfo = info;
+							return undefined;
 						},
 						name => {
 							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
@@ -1422,7 +1441,7 @@ class JavascriptParser extends Parser {
 				};
 			}
 		});
-		tapEvaluateWithVariableInfo("ThisExpression", expr => {
+		tapEvaluateWithVariableInfo("ThisExpression", _expr => {
 			const info = this.getVariableInfo("this");
 			if (
 				typeof info === "string" ||
@@ -1660,6 +1679,7 @@ class JavascriptParser extends Parser {
 				if (!param.isString() && !param.isWrapped()) return;
 				let stringSuffix = null;
 				let hasUnknownParams = false;
+				/** @type {BasicEvaluatedExpression[]} */
 				const innerExpressions = [];
 				for (let i = expr.arguments.length - 1; i >= 0; i--) {
 					const arg = expr.arguments[i];
@@ -1699,7 +1719,10 @@ class JavascriptParser extends Parser {
 					const prefix = param.isString() ? param : param.prefix;
 					const inner =
 						param.isWrapped() && param.wrappedInnerExpressions
-							? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+							? [
+									...param.wrappedInnerExpressions,
+									...innerExpressions.reverse()
+								]
 							: innerExpressions.reverse();
 					return new BasicEvaluatedExpression()
 						.setWrapped(prefix, stringSuffix, inner)
@@ -1707,7 +1730,7 @@ class JavascriptParser extends Parser {
 				} else if (param.isWrapped()) {
 					const postfix = stringSuffix || param.postfix;
 					const inner = param.wrappedInnerExpressions
-						? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+						? [...param.wrappedInnerExpressions, ...innerExpressions.reverse()]
 						: innerExpressions.reverse();
 					return new BasicEvaluatedExpression()
 						.setWrapped(param.prefix, postfix, inner)
@@ -1877,13 +1900,20 @@ class JavascriptParser extends Parser {
 				scopeParams.push(classy.id);
 			}
 			this.inClassScope(true, scopeParams, () => {
-				for (const classElement of /** @type {TODO} */ (classy.body.body)) {
+				for (const classElement of classy.body.body) {
 					if (!this.hooks.classBodyElement.call(classElement, classy)) {
-						if (classElement.computed && classElement.key) {
-							this.walkExpression(classElement.key);
-						}
-						if (classElement.value) {
+						if (classElement.type === "StaticBlock") {
+							const wasTopLevel = this.scope.topLevelScope;
+							this.scope.topLevelScope = false;
+							this.walkBlockStatement(classElement);
+							this.scope.topLevelScope = wasTopLevel;
+						} else {
+							if (classElement.computed && classElement.key) {
+								this.walkExpression(classElement.key);
+							}
+
 							if (
+								classElement.value &&
 								!this.hooks.classBodyValue.call(
 									classElement.value,
 									classElement,
@@ -1895,11 +1925,6 @@ class JavascriptParser extends Parser {
 								this.walkExpression(classElement.value);
 								this.scope.topLevelScope = wasTopLevel;
 							}
-						} else if (classElement.type === "StaticBlock") {
-							const wasTopLevel = this.scope.topLevelScope;
-							this.scope.topLevelScope = false;
-							this.walkBlockStatement(classElement);
-							this.scope.topLevelScope = wasTopLevel;
 						}
 					}
 				}
@@ -1939,8 +1964,13 @@ class JavascriptParser extends Parser {
 		for (let index = 0, len = statements.length; index < len; index++) {
 			const statement = statements[index];
 
-			if (onlyFunctionDeclaration && statement.type !== "FunctionDeclaration")
+			if (
+				onlyFunctionDeclaration &&
+				statement.type !== "FunctionDeclaration" &&
+				this.hooks.unusedStatement.call(/** @type {Statement} */ (statement))
+			) {
 				continue;
+			}
 
 			this.walkStatement(statement);
 
@@ -2144,7 +2174,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {BlockStatement} statement block statement
+	 * @param {BlockStatement | StaticBlock} statement block statement
 	 */
 	walkBlockStatement(statement) {
 		this.inBlockScope(() => {
@@ -2537,8 +2567,9 @@ class JavascriptParser extends Parser {
 		if (
 			expression.left.type !== "ObjectPattern" ||
 			!this.destructuringAssignmentProperties
-		)
+		) {
 			return;
+		}
 		const keys = this._preWalkObjectPattern(expression.left);
 		if (!keys) return;
 
@@ -2808,16 +2839,19 @@ class JavascriptParser extends Parser {
 	 */
 	blockPreWalkVariableDeclaration(statement) {
 		if (statement.kind === "var") return;
+
 		const hookMap =
 			statement.kind === "const"
 				? this.hooks.varDeclarationConst
-				: this.hooks.varDeclarationLet;
+				: statement.kind === "using" || statement.kind === "await using"
+					? this.hooks.varDeclarationUsing
+					: this.hooks.varDeclarationLet;
 		this._preWalkVariableDeclaration(statement, hookMap);
 	}
 
 	/**
 	 * @param {VariableDeclaration} statement variable declaration
-	 * @param {TODO} hookMap map of hooks
+	 * @param {HookMap<SyncBailHook<[Identifier], boolean | void>>} hookMap map of hooks
 	 */
 	_preWalkVariableDeclaration(statement, hookMap) {
 		for (const declarator of statement.declarations) {
@@ -2825,11 +2859,11 @@ class JavascriptParser extends Parser {
 				case "VariableDeclarator": {
 					this.preWalkVariableDeclarator(declarator);
 					if (!this.hooks.preDeclarator.call(declarator, statement)) {
-						this.enterPattern(declarator.id, (name, decl) => {
+						this.enterPattern(declarator.id, (name, ident) => {
 							let hook = hookMap.get(name);
-							if (hook === undefined || !hook.call(decl)) {
+							if (hook === undefined || !hook.call(ident)) {
 								hook = this.hooks.varDeclaration.get(name);
-								if (hook === undefined || !hook.call(decl)) {
+								if (hook === undefined || !hook.call(ident)) {
 									this.defineVariable(name);
 								}
 							}
@@ -2852,11 +2886,18 @@ class JavascriptParser extends Parser {
 		for (let i = 0; i < properties.length; i++) {
 			const property = properties[i];
 			if (property.type !== "Property") return;
-			if (property.shorthand && property.value.type === "Identifier") {
-				this.scope.inShorthand = property.value.name;
+			if (property.shorthand) {
+				if (property.value.type === "Identifier") {
+					this.scope.inShorthand = property.value.name;
+				} else if (
+					property.value.type === "AssignmentPattern" &&
+					property.value.left.type === "Identifier"
+				) {
+					this.scope.inShorthand = property.value.left.name;
+				}
 			}
 			const key = property.key;
-			if (key.type === "Identifier") {
+			if (key.type === "Identifier" && !property.computed) {
 				props.add({
 					id: key.name,
 					range: key.range,
@@ -2890,8 +2931,9 @@ class JavascriptParser extends Parser {
 			!declarator.init ||
 			declarator.id.type !== "ObjectPattern" ||
 			!this.destructuringAssignmentProperties
-		)
+		) {
 			return;
+		}
 		const keys = this._preWalkObjectPattern(declarator.id);
 
 		if (!keys) return;
@@ -3197,8 +3239,9 @@ class JavascriptParser extends Parser {
 	 * @param {AwaitExpression} expression await expression
 	 */
 	walkAwaitExpression(expression) {
-		if (this.scope.topLevelScope === true)
+		if (this.scope.topLevelScope === true) {
 			this.hooks.topLevelAwait.call(expression);
+		}
 		this.walkExpression(expression.argument);
 	}
 
@@ -3438,7 +3481,7 @@ class JavascriptParser extends Parser {
 				return;
 			}
 			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, decl) => {
+			this.enterPattern(expression.left, (name, _decl) => {
 				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
 					this.walkExpression(
 						/** @type {MemberExpression} */
@@ -3448,7 +3491,7 @@ class JavascriptParser extends Parser {
 			});
 		} else if (expression.left.type.endsWith("Pattern")) {
 			this.walkExpression(expression.right);
-			this.enterPattern(expression.left, (name, decl) => {
+			this.enterPattern(expression.left, (name, _decl) => {
 				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
 					this.defineVariable(name);
 				}
@@ -3751,8 +3794,9 @@ class JavascriptParser extends Parser {
 				if (expression.callee.type === "MemberExpression") {
 					// because of call context we need to walk the call context as expression
 					this.walkExpression(expression.callee.object);
-					if (expression.callee.computed === true)
+					if (expression.callee.computed === true) {
 						this.walkExpression(expression.callee.property);
+					}
 				} else {
 					this.walkExpression(expression.callee);
 				}
@@ -3794,7 +3838,7 @@ class JavascriptParser extends Parser {
 						expression,
 						exprInfo.name,
 						exprInfo.rootInfo,
-						members.slice(),
+						[...members],
 						() =>
 							this.callHooksForInfo(
 								this.hooks.unhandledExpressionMemberChain,
@@ -3914,7 +3958,7 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {Expression | Super} expr expression info
-	 * @param {((name: string, rootInfo: string | ScopeInfo | VariableInfo, getMembers: () => string[]) => TODO) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {((name: string, rootInfo: string | ScopeInfo | VariableInfo, getMembers: () => string[]) => R) | undefined} fallback callback when variable in not handled by hooks
 	 * @param {((result?: string) => R | undefined) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
@@ -3984,7 +4028,7 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {ExportedVariableInfo} info variable info
-	 * @param {((name: string) => TODO) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {((name: string) => R | undefined) | undefined} fallback callback when variable in not handled by hooks
 	 * @param {((result?: string) => TODO) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
@@ -4351,9 +4395,11 @@ class JavascriptParser extends Parser {
 		);
 	}
 
+	/** @typedef {{ range?: Range, value: string, code: boolean, conditional: false | CalculatedStringResult[] }} CalculatedStringResult */
+
 	/**
 	 * @param {Expression} expression expression
-	 * @returns {{ range?: Range, value: string, code: boolean, conditional: boolean | TODO }} result
+	 * @returns {CalculatedStringResult} result
 	 */
 	parseCalculatedString(expression) {
 		switch (expression.type) {
@@ -4401,6 +4447,7 @@ class JavascriptParser extends Parser {
 			case "ConditionalExpression": {
 				const consequent = this.parseCalculatedString(expression.consequent);
 				const alternate = this.parseCalculatedString(expression.alternate);
+				/** @type {CalculatedStringResult[]} */
 				const items = [];
 				if (consequent.conditional) {
 					items.push(...consequent.conditional);
@@ -4453,7 +4500,7 @@ class JavascriptParser extends Parser {
 			throw new Error("source must not be null");
 		}
 		if (Buffer.isBuffer(source)) {
-			source = source.toString("utf-8");
+			source = source.toString("utf8");
 		}
 		if (typeof source === "object") {
 			ast = /** @type {Program} */ (source);
@@ -4552,14 +4599,20 @@ class JavascriptParser extends Parser {
 				) {
 					return false;
 				}
-				const items =
-					/** @type {TODO[]} */
-					(expr.body.body);
+				const items = expr.body.body;
 				return items.every(item => {
+					if (item.type === "StaticBlock") {
+						return false;
+					}
+
 					if (
 						item.computed &&
 						item.key &&
-						!this.isPure(item.key, item.range[0])
+						!this.isPure(
+							item.key,
+							/** @type {Range} */
+							(item.range)[0]
+						)
 					) {
 						return false;
 					}
@@ -4569,16 +4622,14 @@ class JavascriptParser extends Parser {
 						item.value &&
 						!this.isPure(
 							item.value,
-							item.key ? item.key.range[1] : item.range[0]
+							item.key
+								? /** @type {Range} */ (item.key.range)[1]
+								: /** @type {Range} */ (item.range)[0]
 						)
 					) {
 						return false;
 					}
 
-					if (item.type === "StaticBlock") {
-						return false;
-					}
-
 					if (
 						expr.superClass &&
 						item.type === "MethodDefinition" &&
@@ -4802,8 +4853,12 @@ class JavascriptParser extends Parser {
 	defineVariable(name) {
 		const oldInfo = this.scope.definitions.get(name);
 		// Don't redefine variable in same scope to keep existing tags
-		if (oldInfo instanceof VariableInfo && oldInfo.declaredScope === this.scope)
+		if (
+			oldInfo instanceof VariableInfo &&
+			oldInfo.declaredScope === this.scope
+		) {
 			return;
+		}
 		this.scope.definitions.set(name, this.scope);
 	}
 
@@ -5084,9 +5139,9 @@ class JavascriptParser extends Parser {
 
 module.exports = JavascriptParser;
 module.exports.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
-module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
-	ALLOWED_MEMBER_TYPES_EXPRESSION;
 module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
 	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;
-module.exports.getImportAttributes = getImportAttributes;
+module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
+	ALLOWED_MEMBER_TYPES_EXPRESSION;
 module.exports.VariableInfo = VariableInfo;
+module.exports.getImportAttributes = getImportAttributes;

package/lib/javascript/JavascriptParserHelpers.js

@@ -15,46 +15,7 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("./JavascriptParser")} JavascriptParser */
 /** @typedef {import("./JavascriptParser").Range} Range */
 
-/**
- * @param {JavascriptParser} parser the parser
- * @param {string} value the const value
- * @param {(string[] | null)=} runtimeRequirements runtime requirements
- * @returns {(expression: Expression) => true} plugin function
- */
-module.exports.toConstantDependency = (parser, value, runtimeRequirements) =>
-	function constDependency(expr) {
-		const dep = new ConstDependency(
-			value,
-			/** @type {Range} */
-			(expr.range),
-			runtimeRequirements
-		);
-		dep.loc = /** @type {SourceLocation} */ (expr.loc);
-		parser.state.module.addPresentationalDependency(dep);
-		return true;
-	};
-
-/**
- * @param {string} value the string value
- * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
- */
-module.exports.evaluateToString = value =>
-	function stringExpression(expr) {
-		return new BasicEvaluatedExpression()
-			.setString(value)
-			.setRange(/** @type {Range} */ (expr.range));
-	};
-
-/**
- * @param {number} value the number value
- * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
- */
-module.exports.evaluateToNumber = value =>
-	function stringExpression(expr) {
-		return new BasicEvaluatedExpression()
-			.setNumber(value)
-			.setRange(/** @type {Range} */ (expr.range));
-	};
+module.exports.approve = () => true;
 
 /**
  * @param {boolean} value the boolean value
@@ -100,6 +61,28 @@ module.exports.evaluateToIdentifier = (
 		return evaluatedExpression;
 	};
 
+/**
+ * @param {number} value the number value
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
+ */
+module.exports.evaluateToNumber = value =>
+	function stringExpression(expr) {
+		return new BasicEvaluatedExpression()
+			.setNumber(value)
+			.setRange(/** @type {Range} */ (expr.range));
+	};
+
+/**
+ * @param {string} value the string value
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
+ */
+module.exports.evaluateToString = value =>
+	function stringExpression(expr) {
+		return new BasicEvaluatedExpression()
+			.setString(value)
+			.setRange(/** @type {Range} */ (expr.range));
+	};
+
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} message the message
@@ -126,4 +109,21 @@ module.exports.expressionIsUnsupported = (parser, message) =>
 
 module.exports.skipTraversal = () => true;
 
-module.exports.approve = () => true;
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} value the const value
+ * @param {(string[] | null)=} runtimeRequirements runtime requirements
+ * @returns {(expression: Expression) => true} plugin function
+ */
+module.exports.toConstantDependency = (parser, value, runtimeRequirements) =>
+	function constDependency(expr) {
+		const dep = new ConstDependency(
+			value,
+			/** @type {Range} */
+			(expr.range),
+			runtimeRequirements
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
+		parser.state.module.addPresentationalDependency(dep);
+		return true;
+	};