webpack 5.97.1 → 5.104.1

package/lib/dependencies/URLPlugin.js

@@ -5,29 +5,18 @@
 
 "use strict";
 
-const { pathToFileURL } = require("url");
-const CommentCompilationWarning = require("../CommentCompilationWarning");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
-const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
-const { approve } = require("../javascript/JavascriptParserHelpers");
-const InnerGraph = require("../optimize/InnerGraph");
-const ConstDependency = require("./ConstDependency");
-const URLDependency = require("./URLDependency");
 
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("estree").NewExpression} NewExpressionNode */
+const URLContextDependency = require("../dependencies/URLContextDependency");
+const URLDependency = require("../dependencies/URLDependency");
+const URLParserPlugin = require("../url/URLParserPlugin");
+
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser")} Parser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const PLUGIN_NAME = "URLPlugin";
 
@@ -38,168 +27,38 @@ class URLPlugin {
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
-			(compilation, { normalModuleFactory }) => {
+			(compilation, { normalModuleFactory, contextModuleFactory }) => {
 				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
 				compilation.dependencyTemplates.set(
 					URLDependency,
 					new URLDependency.Template()
 				);
+				compilation.dependencyFactories.set(
+					URLContextDependency,
+					contextModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					URLContextDependency,
+					new URLContextDependency.Template()
+				);
 
 				/**
-				 * @param {NormalModule} module module
-				 * @returns {URL} file url
-				 */
-				const getUrl = module => pathToFileURL(module.resource);
-
-				/**
-				 * @param {Parser} parser parser parser
-				 * @param {MemberExpression} arg arg
-				 * @returns {boolean} true when it is `meta.url`, otherwise false
-				 */
-				const isMetaUrl = (parser, arg) => {
-					const chain = parser.extractMemberExpressionChain(arg);
-
-					if (
-						chain.members.length !== 1 ||
-						chain.object.type !== "MetaProperty" ||
-						chain.object.meta.name !== "import" ||
-						chain.object.property.name !== "meta" ||
-						chain.members[0] !== "url"
-					)
-						return false;
-
-					return true;
-				};
-
-				/**
-				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParser} parser parser parser
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
 				 * @returns {void}
 				 */
-				const parserCallback = (parser, parserOptions) => {
+				const handler = (parser, parserOptions) => {
 					if (parserOptions.url === false) return;
-					const relative = parserOptions.url === "relative";
-
-					/**
-					 * @param {NewExpressionNode} expr expression
-					 * @returns {undefined | string} request
-					 */
-					const getUrlRequest = expr => {
-						if (expr.arguments.length !== 2) return;
-
-						const [arg1, arg2] = expr.arguments;
-
-						if (
-							arg2.type !== "MemberExpression" ||
-							arg1.type === "SpreadElement"
-						)
-							return;
-
-						if (!isMetaUrl(parser, arg2)) return;
-
-						return parser.evaluateExpression(arg1).asString();
-					};
-
-					parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
-					parser.hooks.evaluateNewExpression
-						.for("URL")
-						.tap(PLUGIN_NAME, expr => {
-							const request = getUrlRequest(expr);
-							if (!request) return;
-							const url = new URL(request, getUrl(parser.state.module));
-
-							return new BasicEvaluatedExpression()
-								.setString(url.toString())
-								.setRange(/** @type {Range} */ (expr.range));
-						});
-					parser.hooks.new.for("URL").tap(PLUGIN_NAME, _expr => {
-						const expr = /** @type {NewExpressionNode} */ (_expr);
-						const { options: importOptions, errors: commentErrors } =
-							parser.parseCommentOptions(/** @type {Range} */ (expr.range));
-
-						if (commentErrors) {
-							for (const e of commentErrors) {
-								const { comment } = e;
-								parser.state.module.addWarning(
-									new CommentCompilationWarning(
-										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-										/** @type {DependencyLocation} */ (comment.loc)
-									)
-								);
-							}
-						}
-
-						if (importOptions && importOptions.webpackIgnore !== undefined) {
-							if (typeof importOptions.webpackIgnore !== "boolean") {
-								parser.state.module.addWarning(
-									new UnsupportedFeatureWarning(
-										`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-										/** @type {DependencyLocation} */ (expr.loc)
-									)
-								);
-								return;
-							} else if (importOptions.webpackIgnore) {
-								if (expr.arguments.length !== 2) return;
-
-								const [, arg2] = expr.arguments;
-
-								if (
-									arg2.type !== "MemberExpression" ||
-									!isMetaUrl(parser, arg2)
-								)
-									return;
-
-								const dep = new ConstDependency(
-									RuntimeGlobals.baseURI,
-									/** @type {Range} */ (arg2.range),
-									[RuntimeGlobals.baseURI]
-								);
-								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-								parser.state.module.addPresentationalDependency(dep);
-
-								return true;
-							}
-						}
-
-						const request = getUrlRequest(expr);
-
-						if (!request) return;
-
-						const [arg1, arg2] = expr.arguments;
-						const dep = new URLDependency(
-							request,
-							[
-								/** @type {Range} */ (arg1.range)[0],
-								/** @type {Range} */ (arg2.range)[1]
-							],
-							/** @type {Range} */ (expr.range),
-							relative
-						);
-						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-						parser.state.current.addDependency(dep);
-						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
-						return true;
-					});
-					parser.hooks.isPure.for("NewExpression").tap(PLUGIN_NAME, _expr => {
-						const expr = /** @type {NewExpressionNode} */ (_expr);
-						const { callee } = expr;
-						if (callee.type !== "Identifier") return;
-						const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
-						if (!calleeInfo || calleeInfo.name !== "URL") return;
-
-						const request = getUrlRequest(expr);
-
-						if (request) return true;
-					});
+					new URLParserPlugin(parserOptions).apply(parser);
 				};
 
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
-					.tap(PLUGIN_NAME, parserCallback);
+					.tap(PLUGIN_NAME, handler);
 
 				normalModuleFactory.hooks.parser
 					.for(JAVASCRIPT_MODULE_TYPE_ESM)
-					.tap(PLUGIN_NAME, parserCallback);
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/dependencies/WebAssemblyExportImportedDependency.js

@@ -9,7 +9,7 @@ const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -21,7 +21,7 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 	 * @param {string} exportName export name
 	 * @param {string} request request
 	 * @param {string} name name
-	 * @param {TODO} valueType value type
+	 * @param {string} valueType value type
 	 */
 	constructor(exportName, request, name, valueType) {
 		super(request);
@@ -44,7 +44,7 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		return [[this.name]];

package/lib/dependencies/WebAssemblyImportDependency.js

@@ -10,7 +10,7 @@ const UnsupportedWebAssemblyFeatureError = require("../wasm-sync/UnsupportedWebA
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("@webassemblyjs/ast").ModuleImportDescription} ModuleImportDescription */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -46,7 +46,7 @@ class WebAssemblyImportDependency extends ModuleDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		return [[this.name]];

package/lib/dependencies/WebpackIsIncludedDependency.js

@@ -11,8 +11,7 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
@@ -34,7 +33,7 @@ class WebpackIsIncludedDependency extends ModuleDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		// This doesn't use any export

package/lib/dependencies/WorkerDependency.js

@@ -12,8 +12,7 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Entrypoint")} Entrypoint */
@@ -30,6 +29,7 @@ class WorkerDependency extends ModuleDependency {
 	 * @param {Range} range range
 	 * @param {object} workerDependencyOptions options
 	 * @param {string=} workerDependencyOptions.publicPath public path for the worker
+	 * @param {boolean=} workerDependencyOptions.needNewUrl need generate `new URL(...)`
 	 */
 	constructor(request, range, workerDependencyOptions) {
 		super(request);
@@ -44,7 +44,7 @@ class WorkerDependency extends ModuleDependency {
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
-	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		return Dependency.NO_EXPORTS_REFERENCED;
@@ -118,12 +118,14 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 		runtimeRequirements.add(RuntimeGlobals.baseURI);
 		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
 
+		const workerImportStr = `/* worker import */ ${workerImportBaseUrl} + ${
+			RuntimeGlobals.getChunkScriptFilename
+		}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`;
+
 		source.replace(
 			dep.range[0],
 			dep.range[1] - 1,
-			`/* worker import */ ${workerImportBaseUrl} + ${
-				RuntimeGlobals.getChunkScriptFilename
-			}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`
+			dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
 		);
 	}
 };

package/lib/dependencies/WorkerPlugin.js

@@ -27,6 +27,7 @@ const WorkerDependency = require("./WorkerDependency");
 
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").Property} Property */
@@ -40,19 +41,17 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
 /**
  * @param {NormalModule} module module
  * @returns {string} url
  */
-const getUrl = module => pathToFileURL(module.resource).toString();
+const getUrl = (module) => pathToFileURL(module.resource).toString();
 
 const WorkerSpecifierTag = Symbol("worker specifier tag");
 
@@ -63,7 +62,7 @@ const DEFAULT_SYNTAX = [
 	"Worker from worker_threads"
 ];
 
-/** @type {WeakMap<ParserState, number>} */
+/** @type {WeakMap<JavascriptParserState, number>} */
 const workerIndexMap = new WeakMap();
 
 const PLUGIN_NAME = "WorkerPlugin";
@@ -117,45 +116,83 @@ class WorkerPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {Expression} expr expression
-				 * @returns {[BasicEvaluatedExpression, [number, number]] | void} parsed
+				 * @returns {[string, Range] | void} parsed
 				 */
 				const parseModuleUrl = (parser, expr) => {
-					if (
-						expr.type !== "NewExpression" ||
-						expr.callee.type === "Super" ||
-						expr.arguments.length !== 2
-					)
+					if (expr.type !== "NewExpression" || expr.callee.type === "Super") {
 						return;
-					const [arg1, arg2] = expr.arguments;
-					if (arg1.type === "SpreadElement") return;
-					if (arg2.type === "SpreadElement") return;
-					const callee = parser.evaluateExpression(expr.callee);
-					if (!callee.isIdentifier() || callee.identifier !== "URL") return;
-					const arg2Value = parser.evaluateExpression(arg2);
+					}
 					if (
-						!arg2Value.isString() ||
-						!(/** @type {string} */ (arg2Value.string).startsWith("file://")) ||
-						arg2Value.string !== getUrl(parser.state.module)
+						expr.arguments.length === 1 &&
+						expr.arguments[0].type === "MemberExpression" &&
+						isMetaUrl(parser, expr.arguments[0])
 					) {
-						return;
+						const arg1 = expr.arguments[0];
+						return [
+							getUrl(parser.state.module),
+							[
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg1.range)[1]
+							]
+						];
+					} else if (expr.arguments.length === 2) {
+						const [arg1, arg2] = expr.arguments;
+						if (arg1.type === "SpreadElement") return;
+						if (arg2.type === "SpreadElement") return;
+						const callee = parser.evaluateExpression(expr.callee);
+						if (!callee.isIdentifier() || callee.identifier !== "URL") return;
+						const arg2Value = parser.evaluateExpression(arg2);
+						if (
+							!arg2Value.isString() ||
+							!(
+								/** @type {string} */ (arg2Value.string).startsWith("file://")
+							) ||
+							arg2Value.string !== getUrl(parser.state.module)
+						) {
+							return;
+						}
+						const arg1Value = parser.evaluateExpression(arg1);
+						if (!arg1Value.isString()) return;
+						return [
+							/** @type {string} */ (arg1Value.string),
+							[
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg2.range)[1]
+							]
+						];
 					}
-					const arg1Value = parser.evaluateExpression(arg1);
-					return [
-						arg1Value,
-						[
-							/** @type {Range} */ (arg1.range)[0],
-							/** @type {Range} */ (arg2.range)[1]
-						]
-					];
 				};
 
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {MemberExpression} expr expression
+				 * @returns {boolean} is `import.meta.url`
+				 */
+				const isMetaUrl = (parser, expr) => {
+					const chain = parser.extractMemberExpressionChain(expr);
+
+					if (
+						chain.members.length !== 1 ||
+						chain.object.type !== "MetaProperty" ||
+						chain.object.meta.name !== "import" ||
+						chain.object.property.name !== "meta" ||
+						chain.members[0] !== "url"
+					) {
+						return false;
+					}
+
+					return true;
+				};
+
+				/** @typedef {Record<string, EXPECTED_ANY>} Values */
+
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {ObjectExpression} expr expression
-				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Record<string, any>, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
+				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Values, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
 				 */
 				const parseObjectExpression = (parser, expr) => {
-					/** @type {Record<string, any>} */
+					/** @type {Values} */
 					const values = {};
 					/** @type {Record<string, Expression | Pattern>} */
 					const expressions = {};
@@ -174,10 +211,12 @@ class WorkerPlugin {
 							expressions[prop.key.name] = prop.value;
 							if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
 								const value = parser.evaluateExpression(
-									/** @type {Expression} */ (prop.value)
+									/** @type {Expression} */
+									(prop.value)
 								);
-								if (value.isCompileTimeValue())
+								if (value.isCompileTimeValue()) {
 									values[prop.key.name] = value.asCompileTimeValue();
+								}
 							}
 						} else {
 							otherElements.push(prop);
@@ -211,16 +250,34 @@ class WorkerPlugin {
 					 * @param {CallExpression} expr expression
 					 * @returns {boolean | void} true when handled
 					 */
-					const handleNewWorker = expr => {
-						if (expr.arguments.length === 0 || expr.arguments.length > 2)
+					const handleNewWorker = (expr) => {
+						if (expr.arguments.length === 0 || expr.arguments.length > 2) {
 							return;
+						}
 						const [arg1, arg2] = expr.arguments;
 						if (arg1.type === "SpreadElement") return;
 						if (arg2 && arg2.type === "SpreadElement") return;
-						const parsedUrl = parseModuleUrl(parser, arg1);
-						if (!parsedUrl) return;
-						const [url, range] = parsedUrl;
-						if (!url.isString()) return;
+
+						/** @type {string} */
+						let url;
+						/** @type {Range} */
+						let range;
+						/** @type {boolean} */
+						let needNewUrl = false;
+
+						if (arg1.type === "MemberExpression" && isMetaUrl(parser, arg1)) {
+							url = getUrl(parser.state.module);
+							range = [
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg1.range)[1]
+							];
+							needNewUrl = true;
+						} else {
+							const parsedUrl = parseModuleUrl(parser, arg1);
+							if (!parsedUrl) return;
+							[url, range] = parsedUrl;
+						}
+
 						const {
 							expressions,
 							otherElements,
@@ -231,10 +288,10 @@ class WorkerPlugin {
 						} = arg2 && arg2.type === "ObjectExpression"
 							? parseObjectExpression(parser, arg2)
 							: {
-									/** @type {Record<string, Expression | Pattern>} */
-									expressions: {},
+									expressions:
+										/** @type {Record<string, Expression | Pattern>} */ ({}),
 									otherElements: [],
-									/** @type {Record<string, any>} */
+									/** @type {Values} */
 									values: {},
 									spread: false,
 									insertType: arg2 ? "spread" : "argument",
@@ -319,14 +376,9 @@ class WorkerPlugin {
 							const name = `${cachedContextify(
 								parser.state.module.identifier()
 							)}|${i}`;
-							const hash = createHash(
-								/** @type {Algorithm} */
-								(compilation.outputOptions.hashFunction)
-							);
+							const hash = createHash(compilation.outputOptions.hashFunction);
 							hash.update(name);
-							const digest =
-								/** @type {string} */
-								(hash.digest(compilation.outputOptions.hashDigest));
+							const digest = hash.digest(compilation.outputOptions.hashDigest);
 							entryOptions.runtime = digest.slice(
 								0,
 								compilation.outputOptions.hashDigestLength
@@ -342,13 +394,10 @@ class WorkerPlugin {
 							}
 						});
 						block.loc = expr.loc;
-						const dep = new WorkerDependency(
-							/** @type {string} */ (url.string),
-							range,
-							{
-								publicPath: this._workerPublicPath
-							}
-						);
+						const dep = new WorkerDependency(url, range, {
+							publicPath: this._workerPublicPath,
+							needNewUrl
+						});
 						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						block.addDependency(dep);
 						parser.state.module.addBlock(block);
@@ -370,7 +419,7 @@ class WorkerPlugin {
 								);
 								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
-								/** @type {TODO} */
+								/** @type {EXPECTED_ANY} */
 								(expressions).type = undefined;
 							}
 						} else if (insertType === "comma") {
@@ -406,7 +455,13 @@ class WorkerPlugin {
 
 						parser.walkExpression(expr.callee);
 						for (const key of Object.keys(expressions)) {
-							if (expressions[key]) parser.walkExpression(expressions[key]);
+							if (expressions[key]) {
+								if (expressions[key].type.endsWith("Pattern")) continue;
+								parser.walkExpression(
+									/** @type {Expression} */
+									(expressions[key])
+								);
+							}
 						}
 						for (const prop of otherElements) {
 							parser.walkProperty(prop);
@@ -420,7 +475,7 @@ class WorkerPlugin {
 					/**
 					 * @param {string} item item
 					 */
-					const processItem = item => {
+					const processItem = (item) => {
 						if (
 							item.startsWith("*") &&
 							item.includes(".") &&
@@ -430,13 +485,19 @@ class WorkerPlugin {
 							const pattern = item.slice(1, firstDot);
 							const itemMembers = item.slice(firstDot + 1, -2);
 
-							parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
-								if (decl.id.type === "Identifier" && decl.id.name === pattern) {
-									parser.tagVariable(decl.id.name, WorkerSpecifierTag);
-									return true;
+							parser.hooks.preDeclarator.tap(
+								PLUGIN_NAME,
+								(decl, _statement) => {
+									if (
+										decl.id.type === "Identifier" &&
+										decl.id.name === pattern
+									) {
+										parser.tagVariable(decl.id.name, WorkerSpecifierTag);
+										return true;
+									}
 								}
-							});
-							parser.hooks.pattern.for(pattern).tap(PLUGIN_NAME, pattern => {
+							);
+							parser.hooks.pattern.for(pattern).tap(PLUGIN_NAME, (pattern) => {
 								parser.tagVariable(pattern.name, WorkerSpecifierTag);
 								return true;
 							});
@@ -461,7 +522,7 @@ class WorkerPlugin {
 								const source = match[3];
 								(call ? parser.hooks.call : parser.hooks.new)
 									.for(harmonySpecifierTag)
-									.tap(PLUGIN_NAME, expr => {
+									.tap(PLUGIN_NAME, (expr) => {
 										const settings = /** @type {HarmonySettings} */ (
 											parser.currentTagData
 										);
@@ -484,7 +545,9 @@ class WorkerPlugin {
 							for (const itemFromDefault of DEFAULT_SYNTAX) {
 								processItem(itemFromDefault);
 							}
-						} else processItem(item);
+						} else {
+							processItem(item);
+						}
 					}
 				};
 				normalModuleFactory.hooks.parser
@@ -497,4 +560,5 @@ class WorkerPlugin {
 		);
 	}
 }
+
 module.exports = WorkerPlugin;

package/lib/dependencies/getFunctionExpression.js

@@ -12,9 +12,9 @@
 
 /**
  * @param {Expression | SpreadElement} expr expressions
- * @returns {{fn: FunctionExpression | ArrowFunctionExpression, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined } | undefined} function expression with additional information
+ * @returns {{ fn: FunctionExpression | ArrowFunctionExpression, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined } | undefined} function expression with additional information
  */
-module.exports = expr => {
+module.exports = (expr) => {
 	// <FunctionExpression>
 	if (
 		expr.type === "FunctionExpression" ||