webpack 5.99.5 → 5.99.7

package/lib/css/CssModulesPlugin.js

@@ -385,15 +385,17 @@ class CssModulesPlugin {
 					compilation
 				).renderModuleContent.tap(PLUGIN_NAME, (source, module) => {
 					if (module instanceof CssModule && module.hot) {
-						const exports =
-							/** @type {BuildInfo} */
-							(module.buildInfo).cssData.exports;
+						const cssData = /** @type {BuildInfo} */ (module.buildInfo).cssData;
+						if (!cssData) {
+							return source;
+						}
+						const exports = cssData.exports;
 						const stringifiedExports = JSON.stringify(
 							JSON.stringify(
 								Array.from(exports).reduce((obj, [key, value]) => {
 									obj[key] = value;
 									return obj;
-								}, {})
+								}, /** @type {Record<string, string>} */ ({}))
 							)
 						);
 

package/lib/css/CssParser.js

@@ -293,7 +293,7 @@ const eatSemi = walkCssTokens.eatUntil(";");
 
 class CssParser extends Parser {
 	/**
-	 * @param {CssParserOptions} [options] options
+	 * @param {CssParserOptions=} options options
 	 */
 	constructor({
 		defaultMode = "pure",

package/lib/debug/ProfilingPlugin.js

@@ -88,7 +88,7 @@ class Profiler {
 
 	/**
 	 * @param {string} method method name
-	 * @param {Record<string, EXPECTED_ANY>} [params] params
+	 * @param {Record<string, EXPECTED_ANY>=} params params
 	 * @returns {Promise<TODO>} Promise for the result
 	 */
 	sendCommand(method, params) {

package/lib/dependencies/ContextDependencyHelpers.js

@@ -42,7 +42,7 @@ const splitContextFromPrefix = prefix => {
 };
 
 /** @typedef {Partial<Omit<ContextDependencyOptions, "resource">>} PartialContextDependencyOptions */
-/** @typedef {{ new(options: ContextDependencyOptions, range: Range, valueRange: [number, number], ...args: any[]): ContextDependency }} ContextDependencyConstructor */
+/** @typedef {{ new(options: ContextDependencyOptions, range: Range, valueRange: Range, ...args: any[]): ContextDependency }} ContextDependencyConstructor */
 
 /**
  * @param {ContextDependencyConstructor} Dep the Dependency class

package/lib/dependencies/CssIcssImportDependency.js

@@ -16,6 +16,7 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
@@ -26,12 +27,12 @@ class CssIcssImportDependency extends ModuleDependency {
 	 *:import('./style.css') { IMPORTED_NAME: v-primary }
 	 * @param {string} request request request path which needs resolving
 	 * @param {string} exportName export name
-	 * @param {[number, number]} range the range of dependency
+	 * @param {Range} range the range of dependency
 	 */
 	constructor(request, exportName, range) {
 		super(request);
-		this.range = range;
 		this.exportName = exportName;
+		this.range = range;
 	}
 
 	get type() {

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -15,6 +15,8 @@ const HarmonyExports = require("./HarmonyExports");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./HarmonyModulesPlugin").HarmonyModulesPluginOptions} HarmonyModulesPluginOptions */
 
+const PLUGIN_NAME = "HarmonyDetectionParserPlugin";
+
 module.exports = class HarmonyDetectionParserPlugin {
 	/**
 	 * @param {HarmonyModulesPluginOptions} options options
@@ -29,7 +31,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.program.tap("HarmonyDetectionParserPlugin", ast => {
+		parser.hooks.program.tap(PLUGIN_NAME, ast => {
 			const isStrictHarmony =
 				parser.state.module.type === JAVASCRIPT_MODULE_TYPE_ESM;
 			const isHarmony =
@@ -62,7 +64,7 @@ module.exports = class HarmonyDetectionParserPlugin {
 			}
 		});
 
-		parser.hooks.topLevelAwait.tap("HarmonyDetectionParserPlugin", () => {
+		parser.hooks.topLevelAwait.tap(PLUGIN_NAME, () => {
 			const module = parser.state.module;
 			if (!this.topLevelAwait) {
 				throw new Error(
@@ -105,19 +107,11 @@ module.exports = class HarmonyDetectionParserPlugin {
 		for (const identifier of nonHarmonyIdentifiers) {
 			parser.hooks.evaluateTypeof
 				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.typeof
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.evaluate
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", nullInHarmony);
-			parser.hooks.expression
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
-			parser.hooks.call
-				.for(identifier)
-				.tap("HarmonyDetectionParserPlugin", skipInHarmony);
+				.tap(PLUGIN_NAME, nullInHarmony);
+			parser.hooks.typeof.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.evaluate.for(identifier).tap(PLUGIN_NAME, nullInHarmony);
+			parser.hooks.expression.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
+			parser.hooks.call.for(identifier).tap(PLUGIN_NAME, skipInHarmony);
 		}
 	}
 };

package/lib/dependencies/HarmonyExportExpressionDependency.js

@@ -27,7 +27,7 @@ class HarmonyExportExpressionDependency extends NullDependency {
 	 * @param {Range} range range
 	 * @param {Range} rangeStatement range statement
 	 * @param {string} prefix prefix
-	 * @param {string | { range: Range, prefix: string, suffix: string }} [declarationId] declaration id
+	 * @param {string | { range: Range, prefix: string, suffix: string }=} declarationId declaration id
 	 */
 	constructor(range, rangeStatement, prefix, declarationId) {
 		super();

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -226,7 +226,8 @@ const getMode = (moduleGraph, dep, runtimeKey) => {
 
 	const importedExportsType = importedModule.getExportsType(
 		moduleGraph,
-		/** @type {BuildMeta} */ (parentModule.buildMeta).strictHarmonyModule
+		/** @type {BuildMeta} */
+		(parentModule.buildMeta).strictHarmonyModule
 	);
 
 	const ids = dep.getIds(moduleGraph);

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -48,7 +48,7 @@ const harmonySpecifierTag = Symbol("harmony import");
  * @property {number} sourceOrder
  * @property {string} name
  * @property {boolean} await
- * @property {Record<string, any> | undefined} attributes
+ * @property {ImportAttributes=} attributes
  */
 
 module.exports = class HarmonyImportDependencyParserPlugin {

package/lib/dependencies/HarmonyTopLevelThisParserPlugin.js

@@ -12,27 +12,27 @@ const HarmonyExports = require("./HarmonyExports");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "HarmonyTopLevelThisParserPlugin";
+
 class HarmonyTopLevelThisParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.expression
-			.for("this")
-			.tap("HarmonyTopLevelThisParserPlugin", node => {
-				if (!parser.scope.topLevelScope) return;
-				if (HarmonyExports.isEnabled(parser.state)) {
-					const dep = new ConstDependency(
-						"undefined",
-						/** @type {Range} */ (node.range),
-						null
-					);
-					dep.loc = /** @type {DependencyLocation} */ (node.loc);
-					parser.state.module.addPresentationalDependency(dep);
-					return true;
-				}
-			});
+		parser.hooks.expression.for("this").tap(PLUGIN_NAME, node => {
+			if (!parser.scope.topLevelScope) return;
+			if (HarmonyExports.isEnabled(parser.state)) {
+				const dep = new ConstDependency(
+					"undefined",
+					/** @type {Range} */ (node.range),
+					null
+				);
+				dep.loc = /** @type {DependencyLocation} */ (node.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		});
 	}
 }
 

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -52,6 +52,8 @@ function createError(msg, loc) {
 	return error;
 }
 
+const PLUGIN_NAME = "ImportMetaContextDependencyParserPlugin";
+
 module.exports = class ImportMetaContextDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
@@ -60,7 +62,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 	apply(parser) {
 		parser.hooks.evaluateIdentifier
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr =>
+			.tap(PLUGIN_NAME, expr =>
 				evaluateToIdentifier(
 					"import.meta.webpackContext",
 					"import.meta",
@@ -70,7 +72,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 			);
 		parser.hooks.call
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr => {
+			.tap(PLUGIN_NAME, expr => {
 				if (expr.arguments.length < 1 || expr.arguments.length > 2) return;
 				const [directoryNode, optionsNode] = expr.arguments;
 				if (optionsNode && optionsNode.type !== "ObjectExpression") return;

package/lib/dependencies/JsonExportsDependency.js

@@ -22,7 +22,7 @@ const NullDependency = require("./NullDependency");
 /**
  * @callback GetExportsFromDataFn
  * @param {JsonValue} data raw json data
- * @param {number} [curDepth] current depth
+ * @param {number=} curDepth current depth
  * @returns {ExportSpec[] | null} export spec or nothing
  */
 

package/lib/dependencies/LoaderPlugin.js

@@ -31,6 +31,8 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * @property {string=} baseUri target base uri
  */
 
+const PLUGIN_NAME = "LoaderPlugin";
+
 class LoaderPlugin {
 	/**
 	 * Apply the plugin
@@ -39,7 +41,7 @@ class LoaderPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"LoaderPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					LoaderDependency,
@@ -52,10 +54,10 @@ class LoaderPlugin {
 			}
 		);
 
-		compiler.hooks.compilation.tap("LoaderPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			const moduleGraph = compilation.moduleGraph;
 			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderPlugin",
+				PLUGIN_NAME,
 				loaderContext => {
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);

package/lib/dependencies/LocalModulesHelpers.js

@@ -50,7 +50,7 @@ module.exports.addLocalModule = (state, name) => {
 /**
  * @param {ParserState} state parser state
  * @param {string} name name
- * @param {string} [namedModule] named module
+ * @param {string=} namedModule named module
  * @returns {LocalModule | null} local module or null
  */
 module.exports.getLocalModule = (state, name, namedModule) => {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -12,58 +12,58 @@ const RequireContextDependency = require("./RequireContextDependency");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "RequireContextDependencyParserPlugin";
+
 module.exports = class RequireContextDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.call
-			.for("require.context")
-			.tap("RequireContextDependencyParserPlugin", expr => {
-				let regExp = /^\.\/.*$/;
-				let recursive = true;
-				/** @type {ContextMode} */
-				let mode = "sync";
-				switch (expr.arguments.length) {
-					case 4: {
-						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
-						if (!modeExpr.isString()) return;
-						mode = /** @type {ContextMode} */ (modeExpr.string);
-					}
-					// falls through
-					case 3: {
-						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
-						if (!regExpExpr.isRegExp()) return;
-						regExp = /** @type {RegExp} */ (regExpExpr.regExp);
-					}
-					// falls through
-					case 2: {
-						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
-						if (!recursiveExpr.isBoolean()) return;
-						recursive = /** @type {boolean} */ (recursiveExpr.bool);
-					}
-					// falls through
-					case 1: {
-						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
-						if (!requestExpr.isString()) return;
-						const dep = new RequireContextDependency(
-							{
-								request: /** @type {string} */ (requestExpr.string),
-								recursive,
-								regExp,
-								mode,
-								category: "commonjs"
-							},
-							/** @type {Range} */
-							(expr.range)
-						);
-						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-						dep.optional = Boolean(parser.scope.inTry);
-						parser.state.current.addDependency(dep);
-						return true;
-					}
+		parser.hooks.call.for("require.context").tap(PLUGIN_NAME, expr => {
+			let regExp = /^\.\/.*$/;
+			let recursive = true;
+			/** @type {ContextMode} */
+			let mode = "sync";
+			switch (expr.arguments.length) {
+				case 4: {
+					const modeExpr = parser.evaluateExpression(expr.arguments[3]);
+					if (!modeExpr.isString()) return;
+					mode = /** @type {ContextMode} */ (modeExpr.string);
+				}
+				// falls through
+				case 3: {
+					const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+					if (!regExpExpr.isRegExp()) return;
+					regExp = /** @type {RegExp} */ (regExpExpr.regExp);
+				}
+				// falls through
+				case 2: {
+					const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+					if (!recursiveExpr.isBoolean()) return;
+					recursive = /** @type {boolean} */ (recursiveExpr.bool);
+				}
+				// falls through
+				case 1: {
+					const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+					if (!requestExpr.isString()) return;
+					const dep = new RequireContextDependency(
+						{
+							request: /** @type {string} */ (requestExpr.string),
+							recursive,
+							regExp,
+							mode,
+							category: "commonjs"
+						},
+						/** @type {Range} */
+						(expr.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
+					parser.state.current.addDependency(dep);
+					return true;
 				}
-			});
+			}
+		});
 	}
 };

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -17,128 +17,122 @@ const getFunctionExpression = require("./getFunctionExpression");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "RequireEnsureDependenciesBlockParserPlugin";
+
 module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.call
-			.for("require.ensure")
-			.tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
-				/** @type {string | GroupOptions | null} */
-				let chunkName = null;
-				let errorExpressionArg = null;
-				let errorExpression = null;
-				switch (expr.arguments.length) {
-					case 4: {
-						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
+		parser.hooks.call.for("require.ensure").tap(PLUGIN_NAME, expr => {
+			/** @type {string | GroupOptions | null} */
+			let chunkName = null;
+			let errorExpressionArg = null;
+			let errorExpression = null;
+			switch (expr.arguments.length) {
+				case 4: {
+					const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
+					if (!chunkNameExpr.isString()) return;
+					chunkName =
+						/** @type {string} */
+						(chunkNameExpr.string);
+				}
+				// falls through
+				case 3: {
+					errorExpressionArg = expr.arguments[2];
+					errorExpression = getFunctionExpression(errorExpressionArg);
+
+					if (!errorExpression && !chunkName) {
+						const chunkNameExpr = parser.evaluateExpression(expr.arguments[2]);
 						if (!chunkNameExpr.isString()) return;
 						chunkName =
 							/** @type {string} */
 							(chunkNameExpr.string);
 					}
-					// falls through
-					case 3: {
-						errorExpressionArg = expr.arguments[2];
-						errorExpression = getFunctionExpression(errorExpressionArg);
+				}
+				// falls through
+				case 2: {
+					const dependenciesExpr = parser.evaluateExpression(expr.arguments[0]);
+					const dependenciesItems = /** @type {BasicEvaluatedExpression[]} */ (
+						dependenciesExpr.isArray()
+							? dependenciesExpr.items
+							: [dependenciesExpr]
+					);
+					const successExpressionArg = expr.arguments[1];
+					const successExpression = getFunctionExpression(successExpressionArg);
 
-						if (!errorExpression && !chunkName) {
-							const chunkNameExpr = parser.evaluateExpression(
-								expr.arguments[2]
-							);
-							if (!chunkNameExpr.isString()) return;
-							chunkName =
-								/** @type {string} */
-								(chunkNameExpr.string);
-						}
+					if (successExpression) {
+						parser.walkExpressions(successExpression.expressions);
+					}
+					if (errorExpression) {
+						parser.walkExpressions(errorExpression.expressions);
 					}
-					// falls through
-					case 2: {
-						const dependenciesExpr = parser.evaluateExpression(
-							expr.arguments[0]
-						);
-						const dependenciesItems =
-							/** @type {BasicEvaluatedExpression[]} */ (
-								dependenciesExpr.isArray()
-									? dependenciesExpr.items
-									: [dependenciesExpr]
-							);
-						const successExpressionArg = expr.arguments[1];
-						const successExpression =
-							getFunctionExpression(successExpressionArg);
-
-						if (successExpression) {
-							parser.walkExpressions(successExpression.expressions);
-						}
-						if (errorExpression) {
-							parser.walkExpressions(errorExpression.expressions);
-						}
 
-						const depBlock = new RequireEnsureDependenciesBlock(
-							chunkName,
-							/** @type {DependencyLocation} */
-							(expr.loc)
-						);
-						const errorCallbackExists =
-							expr.arguments.length === 4 ||
-							(!chunkName && expr.arguments.length === 3);
-						const dep = new RequireEnsureDependency(
-							/** @type {Range} */ (expr.range),
-							/** @type {Range} */ (expr.arguments[1].range),
-							errorCallbackExists &&
-								/** @type {Range} */ (expr.arguments[2].range)
-						);
-						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-						depBlock.addDependency(dep);
-						const old = parser.state.current;
-						parser.state.current = /** @type {TODO} */ (depBlock);
-						try {
-							let failed = false;
-							parser.inScope([], () => {
-								for (const ee of dependenciesItems) {
-									if (ee.isString()) {
-										const ensureDependency = new RequireEnsureItemDependency(
-											/** @type {string} */ (ee.string)
-										);
-										ensureDependency.loc =
-											/** @type {DependencyLocation} */
-											(expr.loc);
-										depBlock.addDependency(ensureDependency);
-									} else {
-										failed = true;
-									}
-								}
-							});
-							if (failed) {
-								return;
-							}
-							if (successExpression) {
-								if (successExpression.fn.body.type === "BlockStatement") {
-									parser.walkStatement(successExpression.fn.body);
+					const depBlock = new RequireEnsureDependenciesBlock(
+						chunkName,
+						/** @type {DependencyLocation} */
+						(expr.loc)
+					);
+					const errorCallbackExists =
+						expr.arguments.length === 4 ||
+						(!chunkName && expr.arguments.length === 3);
+					const dep = new RequireEnsureDependency(
+						/** @type {Range} */ (expr.range),
+						/** @type {Range} */ (expr.arguments[1].range),
+						errorCallbackExists &&
+							/** @type {Range} */ (expr.arguments[2].range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					depBlock.addDependency(dep);
+					const old = parser.state.current;
+					parser.state.current = /** @type {TODO} */ (depBlock);
+					try {
+						let failed = false;
+						parser.inScope([], () => {
+							for (const ee of dependenciesItems) {
+								if (ee.isString()) {
+									const ensureDependency = new RequireEnsureItemDependency(
+										/** @type {string} */ (ee.string)
+									);
+									ensureDependency.loc =
+										/** @type {DependencyLocation} */
+										(expr.loc);
+									depBlock.addDependency(ensureDependency);
 								} else {
-									parser.walkExpression(successExpression.fn.body);
+									failed = true;
 								}
 							}
-							old.addBlock(depBlock);
-						} finally {
-							parser.state.current = old;
-						}
-						if (!successExpression) {
-							parser.walkExpression(successExpressionArg);
+						});
+						if (failed) {
+							return;
 						}
-						if (errorExpression) {
-							if (errorExpression.fn.body.type === "BlockStatement") {
-								parser.walkStatement(errorExpression.fn.body);
+						if (successExpression) {
+							if (successExpression.fn.body.type === "BlockStatement") {
+								parser.walkStatement(successExpression.fn.body);
 							} else {
-								parser.walkExpression(errorExpression.fn.body);
+								parser.walkExpression(successExpression.fn.body);
 							}
-						} else if (errorExpressionArg) {
-							parser.walkExpression(errorExpressionArg);
 						}
-						return true;
+						old.addBlock(depBlock);
+					} finally {
+						parser.state.current = old;
+					}
+					if (!successExpression) {
+						parser.walkExpression(successExpressionArg);
+					}
+					if (errorExpression) {
+						if (errorExpression.fn.body.type === "BlockStatement") {
+							parser.walkStatement(errorExpression.fn.body);
+						} else {
+							parser.walkExpression(errorExpression.fn.body);
+						}
+					} else if (errorExpressionArg) {
+						parser.walkExpression(errorExpressionArg);
 					}
+					return true;
 				}
-			});
+			}
+		});
 	}
 };

package/lib/dependencies/RequireResolveDependency.js

@@ -19,7 +19,7 @@ class RequireResolveDependency extends ModuleDependency {
 	/**
 	 * @param {string} request the request string
 	 * @param {Range} range location in source code
-	 * @param {string} [context] context
+	 * @param {string=} context context
 	 */
 	constructor(request, range, context) {
 		super(request);

package/lib/dependencies/WorkerPlugin.js

@@ -119,7 +119,7 @@ class WorkerPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {Expression} expr expression
-				 * @returns {[string, [number, number]] | void} parsed
+				 * @returns {[string, Range] | void} parsed
 				 */
 				const parseModuleUrl = (parser, expr) => {
 					if (expr.type !== "NewExpression" || expr.callee.type === "Super")
@@ -259,7 +259,7 @@ class WorkerPlugin {
 
 						/** @type {string} */
 						let url;
-						/** @type {[number, number]} */
+						/** @type {Range} */
 						let range;
 						/** @type {boolean} */
 						let needNewUrl = false;