webpack 5.76.1 → 5.88.2

package/lib/dependencies/URLPlugin.js

@@ -6,15 +6,25 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const InnerGraph = require("../optimize/InnerGraph");
 const URLDependency = require("./URLDependency");
 
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
+/** @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";
 
 class URLPlugin {
 	/**
@@ -22,7 +32,7 @@ class URLPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"URLPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
 				compilation.dependencyTemplates.set(
@@ -37,9 +47,11 @@ class URLPlugin {
 				const getUrl = module => {
 					return pathToFileURL(module.resource);
 				};
+
 				/**
-				 * @param {JavascriptParser} parser parser
-				 * @param {object} parserOptions options
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
 				 */
 				const parserCallback = (parser, parserOptions) => {
 					if (parserOptions.url === false) return;
@@ -71,24 +83,22 @@ class URLPlugin {
 						)
 							return;
 
-						const request = parser.evaluateExpression(arg1).asString();
-
-						return request;
+						return parser.evaluateExpression(arg1).asString();
 					};
 
-					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
+					parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
 					parser.hooks.evaluateNewExpression
 						.for("URL")
-						.tap("URLPlugin", expr => {
+						.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(expr.range);
+								.setRange(/** @type {Range} */ (expr.range));
 						});
-					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
+					parser.hooks.new.for("URL").tap(PLUGIN_NAME, _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
 
 						const request = getUrlRequest(expr);
@@ -98,16 +108,19 @@ class URLPlugin {
 						const [arg1, arg2] = expr.arguments;
 						const dep = new URLDependency(
 							request,
-							[arg1.range[0], arg2.range[1]],
-							expr.range,
+							[
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg2.range)[1]
+							],
+							/** @type {Range} */ (expr.range),
 							relative
 						);
-						dep.loc = expr.loc;
+						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("URLPlugin", _expr => {
+					parser.hooks.isPure.for("NewExpression").tap(PLUGIN_NAME, _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
 						const { callee } = expr;
 						if (callee.type !== "Identifier") return;
@@ -121,12 +134,12 @@ class URLPlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("URLPlugin", parserCallback);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parserCallback);
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("URLPlugin", parserCallback);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parserCallback);
 			}
 		);
 	}

package/lib/dependencies/UnsupportedDependency.js

@@ -11,8 +11,15 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 class UnsupportedDependency extends NullDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
 	constructor(request, range) {
 		super();
 
@@ -20,6 +27,9 @@ class UnsupportedDependency extends NullDependency {
 		this.range = range;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -29,6 +39,9 @@ class UnsupportedDependency extends NullDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/dependencies/WebAssemblyExportImportedDependency.js

@@ -12,9 +12,17 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class WebAssemblyExportImportedDependency extends ModuleDependency {
+	/**
+	 * @param {string} exportName export name
+	 * @param {string} request request
+	 * @param {string} name name
+	 * @param {TODO} valueType value type
+	 */
 	constructor(exportName, request, name, valueType) {
 		super(request);
 		/** @type {string} */
@@ -50,6 +58,9 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 		return "wasm";
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -60,6 +71,9 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/dependencies/WebAssemblyImportDependency.js

@@ -13,6 +13,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class WebAssemblyImportDependency extends ModuleDependency {
@@ -53,7 +55,7 @@ class WebAssemblyImportDependency extends ModuleDependency {
 	/**
 	 * Returns errors
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {WebpackError[]} errors
+	 * @returns {WebpackError[] | null | undefined} errors
 	 */
 	getErrors(moduleGraph) {
 		const module = moduleGraph.getModule(this);
@@ -71,6 +73,9 @@ class WebAssemblyImportDependency extends ModuleDependency {
 		}
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -81,6 +86,9 @@ class WebAssemblyImportDependency extends ModuleDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/dependencies/WebpackIsIncludedDependency.js

@@ -15,9 +15,14 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class WebpackIsIncludedDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
 	constructor(request, range) {
 		super(request);
 

package/lib/dependencies/WorkerDependency.js

@@ -18,17 +18,26 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class WorkerDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
-	 * @param {[number, number]} range range
+	 * @param {Range} range range
+	 * @param {Object} workerDependencyOptions options
+	 * @param {string} workerDependencyOptions.publicPath public path for the worker
 	 */
-	constructor(request, range) {
+	constructor(request, range, workerDependencyOptions) {
 		super(request);
 		this.range = range;
+		// If options are updated, don't forget to update the hash and serialization functions
+		this.options = workerDependencyOptions;
+		/** Cache the hash */
+		this._hashUpdate = undefined;
 	}
 
 	/**
@@ -48,6 +57,37 @@ class WorkerDependency extends ModuleDependency {
 	get category() {
 		return "worker";
 	}
+
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = JSON.stringify(this.options);
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.options);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.options = read();
+		super.deserialize(context);
+	}
 }
 
 WorkerDependency.Template = class WorkerDependencyTemplate extends (
@@ -69,6 +109,10 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 			chunkGraph.getBlockChunkGroup(block)
 		);
 		const chunk = entrypoint.getEntrypointChunk();
+		// We use the workerPublicPath option if provided, else we fallback to the RuntimeGlobal publicPath
+		const workerImportBaseUrl = dep.options.publicPath
+			? `"${dep.options.publicPath}"`
+			: RuntimeGlobals.publicPath;
 
 		runtimeRequirements.add(RuntimeGlobals.publicPath);
 		runtimeRequirements.add(RuntimeGlobals.baseURI);
@@ -77,7 +121,7 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 		source.replace(
 			dep.range[0],
 			dep.range[1] - 1,
-			`/* worker import */ ${RuntimeGlobals.publicPath} + ${
+			`/* worker import */ ${workerImportBaseUrl} + ${
 				RuntimeGlobals.getChunkScriptFilename
 			}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`
 		);

package/lib/dependencies/WorkerPlugin.js

@@ -8,6 +8,10 @@
 const { pathToFileURL } = require("url");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const { equals } = require("../util/ArrayHelpers");
@@ -21,22 +25,38 @@ const {
 } = require("./HarmonyImportDependencyParserPlugin");
 const WorkerDependency = require("./WorkerDependency");
 
+/** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
+/** @typedef {import("../../declarations/WebpackOptions").ChunkLoading} ChunkLoading */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").OutputModule} OutputModule */
+/** @typedef {import("../../declarations/WebpackOptions").WasmLoading} WasmLoading */
+/** @typedef {import("../../declarations/WebpackOptions").WorkerPublicPath} WorkerPublicPath */
 /** @typedef {import("../Compiler")} Compiler */
+/** @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").Range} Range */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
+/**
+ * @param {NormalModule} module module
+ * @returns {string} url
+ */
 const getUrl = module => {
 	return pathToFileURL(module.resource).toString();
 };
 
+const WorkerSpecifierTag = Symbol("worker specifier tag");
+
 const DEFAULT_SYNTAX = [
 	"Worker",
 	"SharedWorker",
@@ -47,11 +67,20 @@ const DEFAULT_SYNTAX = [
 /** @type {WeakMap<ParserState, number>} */
 const workerIndexMap = new WeakMap();
 
+const PLUGIN_NAME = "WorkerPlugin";
+
 class WorkerPlugin {
-	constructor(chunkLoading, wasmLoading, module) {
+	/**
+	 * @param {ChunkLoading} chunkLoading chunk loading
+	 * @param {WasmLoading} wasmLoading wasm loading
+	 * @param {OutputModule} module output module
+	 * @param {WorkerPublicPath} workerPublicPath worker public path
+	 */
+	constructor(chunkLoading, wasmLoading, module, workerPublicPath) {
 		this._chunkLoading = chunkLoading;
 		this._wasmLoading = wasmLoading;
 		this._module = module;
+		this._workerPublicPath = workerPublicPath;
 	}
 	/**
 	 * Apply the plugin
@@ -70,7 +99,7 @@ class WorkerPlugin {
 			compiler.root
 		);
 		compiler.hooks.thisCompilation.tap(
-			"WorkerPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					WorkerDependency,
@@ -88,7 +117,7 @@ class WorkerPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {Expression} expr expression
-				 * @returns {[BasicEvaluatedExpression, [number, number]]} parsed
+				 * @returns {[BasicEvaluatedExpression, [number, number]] | void} parsed
 				 */
 				const parseModuleUrl = (parser, expr) => {
 					if (
@@ -105,13 +134,19 @@ class WorkerPlugin {
 					const arg2Value = parser.evaluateExpression(arg2);
 					if (
 						!arg2Value.isString() ||
-						!arg2Value.string.startsWith("file://") ||
+						!(/** @type {string} */ (arg2Value.string).startsWith("file://")) ||
 						arg2Value.string !== getUrl(parser.state.module)
 					) {
 						return;
 					}
 					const arg1Value = parser.evaluateExpression(arg1);
-					return [arg1Value, [arg1.range[0], arg2.range[1]]];
+					return [
+						arg1Value,
+						[
+							/** @type {Range} */ (arg1.range)[0],
+							/** @type {Range} */ (arg2.range)[1]
+						]
+					];
 				};
 
 				/**
@@ -162,14 +197,19 @@ class WorkerPlugin {
 				};
 
 				/**
-				 * @param {JavascriptParser} parser the parser
-				 * @param {object} parserOptions options
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
 				 */
 				const parserPlugin = (parser, parserOptions) => {
 					if (parserOptions.worker === false) return;
 					const options = !Array.isArray(parserOptions.worker)
 						? ["..."]
 						: parserOptions.worker;
+					/**
+					 * @param {CallExpression} expr expression
+					 * @returns {boolean | void} true when handled
+					 */
 					const handleNewWorker = expr => {
 						if (expr.arguments.length === 0 || expr.arguments.length > 2)
 							return;
@@ -197,10 +237,12 @@ class WorkerPlugin {
 									values: {},
 									spread: false,
 									insertType: arg2 ? "spread" : "argument",
-									insertLocation: arg2 ? arg2.range : arg1.range[1]
+									insertLocation: arg2
+										? /** @type {Range} */ (arg2.range)
+										: /** @type {Range} */ (arg1.range)[1]
 							  };
 						const { options: importOptions, errors: commentErrors } =
-							parser.parseCommentOptions(expr.range);
+							parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
 						if (commentErrors) {
 							for (const e of commentErrors) {
@@ -223,7 +265,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
 								} else {
@@ -240,7 +282,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
 								} else {
@@ -255,7 +297,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-											expr.loc
+											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
 								} else {
@@ -298,16 +340,22 @@ class WorkerPlugin {
 							}
 						});
 						block.loc = expr.loc;
-						const dep = new WorkerDependency(url.string, range);
-						dep.loc = expr.loc;
+						const dep = new WorkerDependency(
+							/** @type {string} */ (url.string),
+							range,
+							{
+								publicPath: this._workerPublicPath
+							}
+						);
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						block.addDependency(dep);
 						parser.state.module.addBlock(block);
 
 						if (compilation.outputOptions.trustedTypes) {
 							const dep = new CreateScriptUrlDependency(
-								expr.arguments[0].range
+								/** @type {Range} */ (expr.arguments[0].range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addDependency(dep);
 						}
 
@@ -316,9 +364,9 @@ class WorkerPlugin {
 							if (options.type !== false) {
 								const dep = new ConstDependency(
 									this._module ? '"module"' : "undefined",
-									expr.range
+									/** @type {Range} */ (expr.range)
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 								expressions.type = undefined;
 							}
@@ -328,20 +376,20 @@ class WorkerPlugin {
 									`, type: ${this._module ? '"module"' : "undefined"}`,
 									insertLocation
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 							}
 						} else if (insertType === "spread") {
 							const dep1 = new ConstDependency(
 								"Object.assign({}, ",
-								insertLocation[0]
+								/** @type {Range} */ (insertLocation)[0]
 							);
 							const dep2 = new ConstDependency(
 								`, { type: ${this._module ? '"module"' : "undefined"} })`,
-								insertLocation[1]
+								/** @type {Range} */ (insertLocation)[1]
 							);
-							dep1.loc = expr.loc;
-							dep2.loc = expr.loc;
+							dep1.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep2.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep1);
 							parser.state.module.addPresentationalDependency(dep2);
 						} else if (insertType === "argument") {
@@ -350,7 +398,7 @@ class WorkerPlugin {
 									', { type: "module" }',
 									insertLocation
 								);
-								dep.loc = expr.loc;
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
 							}
 						}
@@ -368,11 +416,36 @@ class WorkerPlugin {
 
 						return true;
 					};
+					/**
+					 * @param {string} item item
+					 */
 					const processItem = item => {
-						if (item.endsWith("()")) {
+						if (
+							item.startsWith("*") &&
+							item.includes(".") &&
+							item.endsWith("()")
+						) {
+							const firstDot = item.indexOf(".");
+							const pattern = item.slice(1, firstDot);
+							const itemMembers = item.slice(firstDot + 1, -2);
+
+							parser.hooks.pattern.for(pattern).tap(PLUGIN_NAME, pattern => {
+								parser.tagVariable(pattern.name, WorkerSpecifierTag);
+								return true;
+							});
+							parser.hooks.callMemberChain
+								.for(WorkerSpecifierTag)
+								.tap(PLUGIN_NAME, (expression, members) => {
+									if (itemMembers !== members.join(".")) {
+										return;
+									}
+
+									return handleNewWorker(expression);
+								});
+						} else if (item.endsWith("()")) {
 							parser.hooks.call
 								.for(item.slice(0, -2))
-								.tap("WorkerPlugin", handleNewWorker);
+								.tap(PLUGIN_NAME, handleNewWorker);
 						} else {
 							const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
 							if (match) {
@@ -381,7 +454,7 @@ class WorkerPlugin {
 								const source = match[3];
 								(call ? parser.hooks.call : parser.hooks.new)
 									.for(harmonySpecifierTag)
-									.tap("WorkerPlugin", expr => {
+									.tap(PLUGIN_NAME, expr => {
 										const settings = /** @type {HarmonySettings} */ (
 											parser.currentTagData
 										);
@@ -395,7 +468,7 @@ class WorkerPlugin {
 										return handleNewWorker(expr);
 									});
 							} else {
-								parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
+								parser.hooks.new.for(item).tap(PLUGIN_NAME, handleNewWorker);
 							}
 						}
 					};
@@ -406,11 +479,11 @@ class WorkerPlugin {
 					}
 				};
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WorkerPlugin", parserPlugin);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parserPlugin);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WorkerPlugin", parserPlugin);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parserPlugin);
 			}
 		);
 	}

package/lib/dependencies/getFunctionExpression.js

@@ -5,6 +5,13 @@
 
 "use strict";
 
+/** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").SpreadElement} SpreadElement */
+
+/**
+ * @param {Expression} expr expressions
+ * @returns {{fn: TODO, expressions: (Expression | SpreadElement)[], needThis: boolean | undefined }} function expression with additional information
+ */
 module.exports = expr => {
 	// <FunctionExpression>
 	if (

package/lib/esm/ExportWebpackRequireRuntimeModule.js

@@ -4,6 +4,7 @@
 
 "use strict";
 
+const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
 class ExportWebpackRequireRuntimeModule extends RuntimeModule {
@@ -19,10 +20,10 @@ class ExportWebpackRequireRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		return "export default __webpack_require__;";
+		return `export default ${RuntimeGlobals.require};`;
 	}
 }