@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/dependencies/{WorkerPlugin.js → WorkerAndWorkletPlugin.js}

@@ -7,13 +7,14 @@
 
 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 CommentCompilationWarning = require("../errors/CommentCompilationWarning");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
+const parseResourceHintOptions = require("../prefetch/parseResourceHintOptions");
 const { equals } = require("../util/ArrayHelpers");
 const createHash = require("../util/createHash");
 const { contextify } = require("../util/identifier");
@@ -23,7 +24,9 @@ const CreateScriptUrlDependency = require("./CreateScriptUrlDependency");
 const {
 	harmonySpecifierTag
 } = require("./HarmonyImportDependencyParserPlugin");
+const { isImportMetaFieldEnabled } = require("./ImportMetaPlugin");
 const WorkerDependency = require("./WorkerDependency");
+const WorkletDependency = require("./WorkletDependency");
 
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
@@ -46,43 +49,72 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("../javascript/JavascriptParser").JavascriptParserState} JavascriptParserState */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
+/** @typedef {import("./WorkerDependency").ResourceHint} ResourceHint */
 
 /**
+ * Returns url.
  * @param {NormalModule} module module
  * @returns {string} url
  */
 const getUrl = (module) => pathToFileURL(module.resource).toString();
 
 const WorkerSpecifierTag = Symbol("worker specifier tag");
+const WorkletSpecifierTag = Symbol("worklet specifier tag");
 
-const DEFAULT_SYNTAX = [
+const WORKER_DEFAULT_SYNTAX = [
 	"Worker",
 	"SharedWorker",
 	"navigator.serviceWorker.register()",
 	"Worker from worker_threads"
 ];
 
+// Worklets are always module scripts loaded through `addModule` and — unlike Web
+// Workers — cannot load additional chunks at runtime (no `importScripts`, no
+// dynamic `import()`). The WorkletDependency wraps the call so every chunk is
+// pre-added via `addModule` from the calling scope (see WorkletDependency).
+const WORKLET_DEFAULT_SYNTAX = [
+	"*context.audioWorklet.addModule()",
+	"*audioWorklet.addModule()",
+	"CSS.paintWorklet.addModule()",
+	"CSS.layoutWorklet.addModule()",
+	"CSS.animationWorklet.addModule()"
+];
+
 /** @type {WeakMap<JavascriptParserState, number>} */
 const workerIndexMap = new WeakMap();
 
-const PLUGIN_NAME = "WorkerPlugin";
+const PLUGIN_NAME = "WorkerAndWorkletPlugin";
 
-class WorkerPlugin {
+class WorkerAndWorkletPlugin {
 	/**
+	 * Creates an instance of WorkerAndWorkletPlugin.
 	 * @param {ChunkLoading=} chunkLoading chunk loading
 	 * @param {WasmLoading=} wasmLoading wasm loading
 	 * @param {OutputModule=} module output module
 	 * @param {WorkerPublicPath=} workerPublicPath worker public path
+	 * @param {boolean=} workletDefault whether worklet parsing is on when `parser.worklet` is unset (enabled by `futureDefaults`)
 	 */
-	constructor(chunkLoading, wasmLoading, module, workerPublicPath) {
+	constructor(
+		chunkLoading,
+		wasmLoading,
+		module,
+		workerPublicPath,
+		workletDefault
+	) {
+		/** @type {ChunkLoading | undefined} */
 		this._chunkLoading = chunkLoading;
+		/** @type {WasmLoading | undefined} */
 		this._wasmLoading = wasmLoading;
+		/** @type {boolean | undefined} */
 		this._module = module;
+		/** @type {string | undefined} */
 		this._workerPublicPath = workerPublicPath;
+		/** @type {boolean} */
+		this._workletDefault = Boolean(workletDefault);
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -108,21 +140,54 @@ class WorkerPlugin {
 					WorkerDependency,
 					new WorkerDependency.Template()
 				);
+				compilation.dependencyFactories.set(
+					WorkletDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					WorkletDependency,
+					new WorkletDependency.Template()
+				);
 				compilation.dependencyTemplates.set(
 					CreateScriptUrlDependency,
 					new CreateScriptUrlDependency.Template()
 				);
 
 				/**
+				 * Checks whether the expression is `import.meta.url`.
+				 * @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;
+				};
+
+				/**
+				 * Resolves a `new URL(..., import.meta.url)` argument to its module url.
 				 * @param {JavascriptParser} parser the parser
 				 * @param {Expression} expr expression
+				 * @param {boolean} importMetaUrlEnabled true when import.meta.url should be handled
 				 * @returns {[string, Range] | void} parsed
 				 */
-				const parseModuleUrl = (parser, expr) => {
+				const parseModuleUrl = (parser, expr, importMetaUrlEnabled) => {
 					if (expr.type !== "NewExpression" || expr.callee.type === "Super") {
 						return;
 					}
 					if (
+						importMetaUrlEnabled &&
 						expr.arguments.length === 1 &&
 						expr.arguments[0].type === "MemberExpression" &&
 						isMetaUrl(parser, expr.arguments[0])
@@ -163,30 +228,10 @@ class WorkerPlugin {
 					}
 				};
 
-				/**
-				 * @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 */
 
 				/**
+				 * Parses object expression.
 				 * @param {JavascriptParser} parser the parser
 				 * @param {ObjectExpression} expr expression
 				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Values, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
@@ -223,9 +268,12 @@ class WorkerPlugin {
 						}
 					}
 					const insertType = expr.properties.length > 0 ? "comma" : "single";
-					const insertLocation = /** @type {Range} */ (
-						expr.properties[expr.properties.length - 1].range
-					)[1];
+					const insertLocation =
+						expr.properties.length > 0
+							? /** @type {Range} */ (
+									expr.properties[expr.properties.length - 1].range
+								)[1]
+							: /** @type {Range} */ (expr.range)[0] + 1;
 					return {
 						expressions,
 						otherElements,
@@ -237,20 +285,23 @@ class WorkerPlugin {
 				};
 
 				/**
+				 * Processes the provided parser.
 				 * @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;
+					const importMetaUrlEnabled = isImportMetaFieldEnabled(
+						parserOptions.importMeta,
+						"url"
+					);
+
 					/**
+					 * Resolves the url argument (the `new URL(...)` / bare `import.meta.url`).
 					 * @param {CallExpression} expr expression
-					 * @returns {boolean | void} true when handled
+					 * @returns {{ url: string, range: Range, needNewUrl: boolean, arg1: Expression | SpreadElement, arg2: Expression | SpreadElement | undefined } | void} resolved url info
 					 */
-					const handleNewWorker = (expr) => {
+					const resolveWorkerUrl = (expr) => {
 						if (expr.arguments.length === 0 || expr.arguments.length > 2) {
 							return;
 						}
@@ -262,10 +313,13 @@ class WorkerPlugin {
 						let url;
 						/** @type {Range} */
 						let range;
-						/** @type {boolean} */
 						let needNewUrl = false;
 
-						if (arg1.type === "MemberExpression" && isMetaUrl(parser, arg1)) {
+						if (
+							arg1.type === "MemberExpression" &&
+							importMetaUrlEnabled &&
+							isMetaUrl(parser, arg1)
+						) {
 							url = getUrl(parser.state.module);
 							range = [
 								/** @type {Range} */ (arg1.range)[0],
@@ -273,32 +327,24 @@ class WorkerPlugin {
 							];
 							needNewUrl = true;
 						} else {
-							const parsedUrl = parseModuleUrl(parser, arg1);
+							const parsedUrl = parseModuleUrl(
+								parser,
+								arg1,
+								importMetaUrlEnabled
+							);
 							if (!parsedUrl) return;
 							[url, range] = parsedUrl;
 						}
 
-						const {
-							expressions,
-							otherElements,
-							values: options,
-							spread: hasSpreadInOptions,
-							insertType,
-							insertLocation
-						} = arg2 && arg2.type === "ObjectExpression"
-							? parseObjectExpression(parser, arg2)
-							: {
-									expressions:
-										/** @type {Record<string, Expression | Pattern>} */ ({}),
-									otherElements: [],
-									/** @type {Values} */
-									values: {},
-									spread: false,
-									insertType: arg2 ? "spread" : "argument",
-									insertLocation: arg2
-										? /** @type {Range} */ (arg2.range)
-										: /** @type {Range} */ (arg1.range)[1]
-								};
+						return { url, range, needNewUrl, arg1, arg2 };
+					};
+
+					/**
+					 * Reads the magic-comment entry options for the matched expression.
+					 * @param {CallExpression} expr expression
+					 * @returns {EntryOptions | false} entry options, or false when `webpackIgnore`
+					 */
+					const parseEntryOptions = (expr) => {
 						const { options: importOptions, errors: commentErrors } =
 							parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
@@ -308,7 +354,7 @@ class WorkerPlugin {
 								parser.state.module.addWarning(
 									new CommentCompilationWarning(
 										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
-										/** @type {DependencyLocation} */ (comment.loc)
+										parser.getLocation(comment)
 									)
 								);
 							}
@@ -323,7 +369,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-											/** @type {DependencyLocation} */ (expr.loc)
+											parser.getLocation(expr)
 										)
 									);
 								} else if (importOptions.webpackIgnore) {
@@ -338,14 +384,28 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackEntryOptions\` expected a object, but received: ${importOptions.webpackEntryOptions}.`,
-											/** @type {DependencyLocation} */ (expr.loc)
+											parser.getLocation(expr)
 										)
 									);
 								} else {
-									Object.assign(
-										entryOptions,
-										importOptions.webpackEntryOptions
-									);
+									// `webpackEntryOptions` is user input from a magic
+									// comment, so copy only safe own keys to avoid
+									// prototype pollution via `__proto__`/`constructor`/
+									// `prototype`.
+									const userEntryOptions = importOptions.webpackEntryOptions;
+									for (const key of Object.keys(userEntryOptions)) {
+										if (
+											key === "__proto__" ||
+											key === "constructor" ||
+											key === "prototype"
+										) {
+											continue;
+										}
+										/** @type {EXPECTED_ANY} */
+										(entryOptions)[key] = /** @type {EXPECTED_ANY} */ (
+											userEntryOptions
+										)[key];
+									}
 								}
 							}
 							if (importOptions.webpackChunkName !== undefined) {
@@ -353,7 +413,7 @@ class WorkerPlugin {
 									parser.state.module.addWarning(
 										new UnsupportedFeatureWarning(
 											`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-											/** @type {DependencyLocation} */ (expr.loc)
+											parser.getLocation(expr)
 										)
 									);
 								} else {
@@ -362,6 +422,94 @@ class WorkerPlugin {
 							}
 						}
 
+						return entryOptions;
+					};
+
+					/**
+					 * Assigns a unique runtime to the entry so each worker gets its own runtime chunk.
+					 * @param {EntryOptions} entryOptions entry options
+					 * @returns {void}
+					 */
+					const ensureRuntime = (entryOptions) => {
+						if (entryOptions.runtime !== undefined) return;
+						const i = workerIndexMap.get(parser.state) || 0;
+						workerIndexMap.set(parser.state, i + 1);
+						const name = `${cachedContextify(
+							parser.state.module.identifier()
+						)}|${i}`;
+						const hash = createHash(compilation.outputOptions.hashFunction);
+						hash.update(name);
+						const digest = hash.digest(compilation.outputOptions.hashDigest);
+						entryOptions.runtime = digest.slice(
+							0,
+							compilation.outputOptions.hashDigestLength
+						);
+					};
+
+					/**
+					 * Handles a matched `new Worker(...)` expression.
+					 * @param {CallExpression} expr expression
+					 * @param {boolean=} isGlobalWorker matched the global `new Worker()` syntax (eligible for universal rewrite)
+					 * @returns {boolean | void} true when handled
+					 */
+					const handleNewWorker = (expr, isGlobalWorker = false) => {
+						const parsedUrl = resolveWorkerUrl(expr);
+						if (!parsedUrl) return;
+						const { url, range, needNewUrl, arg1, arg2 } = parsedUrl;
+
+						const {
+							expressions,
+							otherElements,
+							values: options,
+							spread: hasSpreadInOptions,
+							insertType,
+							insertLocation
+						} = arg2 && arg2.type === "ObjectExpression"
+							? parseObjectExpression(parser, arg2)
+							: {
+									expressions:
+										/** @type {Record<string, Expression | Pattern>} */ ({}),
+									otherElements: [],
+									/** @type {Values} */
+									values: {},
+									spread: false,
+									insertType: arg2 ? "spread" : "argument",
+									insertLocation: arg2
+										? /** @type {Range} */ (arg2.range)
+										: /** @type {Range} */ (arg1.range)[1]
+								};
+
+						const entryOptions = parseEntryOptions(expr);
+						if (entryOptions === false) return false;
+
+						/** @type {ResourceHint | undefined} */
+						let resourceHint;
+						// Resource-hint comments belong to the asset expression — read
+						// them from the inner `new URL(...)` range only, never from
+						// elsewhere inside `new Worker(...)`. When `arg1` is bare
+						// `import.meta.url` there is no `new URL` and no place for
+						// the comments to go, so resource hints are skipped.
+						if (arg1.type === "NewExpression") {
+							const { options: urlImportOptions } = parser.parseCommentOptions(
+								/** @type {Range} */ (arg1.range)
+							);
+							const hints = parseResourceHintOptions(
+								urlImportOptions,
+								parser.state.module,
+								/** @type {DependencyLocation} */ (expr.loc)
+							);
+							if (hints.prefetch || hints.preload) {
+								resourceHint = {
+									prefetch: hints.prefetch,
+									preload: hints.preload,
+									fetchPriority: hints.fetchPriority,
+									as: hints.as,
+									type: hints.type,
+									media: hints.media
+								};
+							}
+						}
+
 						if (
 							!Object.prototype.hasOwnProperty.call(entryOptions, "name") &&
 							options &&
@@ -370,20 +518,7 @@ class WorkerPlugin {
 							entryOptions.name = options.name;
 						}
 
-						if (entryOptions.runtime === undefined) {
-							const i = workerIndexMap.get(parser.state) || 0;
-							workerIndexMap.set(parser.state, i + 1);
-							const name = `${cachedContextify(
-								parser.state.module.identifier()
-							)}|${i}`;
-							const hash = createHash(compilation.outputOptions.hashFunction);
-							hash.update(name);
-							const digest = hash.digest(compilation.outputOptions.hashDigest);
-							entryOptions.runtime = digest.slice(
-								0,
-								compilation.outputOptions.hashDigestLength
-							);
-						}
+						ensureRuntime(entryOptions);
 
 						const block = new AsyncDependenciesBlock({
 							name: entryOptions.name,
@@ -391,15 +526,20 @@ class WorkerPlugin {
 							entryOptions: {
 								chunkLoading: this._chunkLoading,
 								wasmLoading: this._wasmLoading,
-								...entryOptions
+								...entryOptions,
+								worker: true
 							}
 						});
-						block.loc = expr.loc;
+						block.loc = parser.getLocation(expr);
 						const dep = new WorkerDependency(url, range, {
 							publicPath: this._workerPublicPath,
-							needNewUrl
+							needNewUrl,
+							workerConstructorRange: isGlobalWorker
+								? /** @type {Range} */ (expr.callee.range)
+								: undefined,
+							resourceHint
 						});
-						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+						dep.loc = parser.getLocation(expr);
 						block.addDependency(dep);
 						parser.state.module.addBlock(block);
 
@@ -407,7 +547,7 @@ class WorkerPlugin {
 							const dep = new CreateScriptUrlDependency(
 								/** @type {Range} */ (expr.arguments[0].range)
 							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep.loc = parser.getLocation(expr);
 							parser.state.module.addDependency(dep);
 						}
 
@@ -418,7 +558,7 @@ class WorkerPlugin {
 									this._module ? '"module"' : "undefined",
 									/** @type {Range} */ (expr.range)
 								);
-								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								dep.loc = parser.getLocation(expr);
 								parser.state.module.addPresentationalDependency(dep);
 								/** @type {EXPECTED_ANY} */
 								(expressions).type = undefined;
@@ -429,20 +569,23 @@ class WorkerPlugin {
 									`, type: ${this._module ? '"module"' : "undefined"}`,
 									insertLocation
 								);
-								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								dep.loc = parser.getLocation(expr);
 								parser.state.module.addPresentationalDependency(dep);
 							}
 						} else if (insertType === "spread") {
+							const type = this._module ? '"module"' : "undefined";
+							// `{ ...(opts), type }` is equivalent to `Object.assign({}, opts, { type })`
+							const useSpread = compilation.outputOptions.environment.spread;
 							const dep1 = new ConstDependency(
-								"Object.assign({}, ",
+								useSpread ? "{ ...(" : "Object.assign({}, ",
 								/** @type {Range} */ (insertLocation)[0]
 							);
 							const dep2 = new ConstDependency(
-								`, { type: ${this._module ? '"module"' : "undefined"} })`,
+								useSpread ? `), type: ${type} }` : `, { type: ${type} })`,
 								/** @type {Range} */ (insertLocation)[1]
 							);
-							dep1.loc = /** @type {DependencyLocation} */ (expr.loc);
-							dep2.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep1.loc = parser.getLocation(expr);
+							dep2.loc = parser.getLocation(expr);
 							parser.state.module.addPresentationalDependency(dep1);
 							parser.state.module.addPresentationalDependency(dep2);
 						} else if (insertType === "argument" && this._module) {
@@ -450,7 +593,7 @@ class WorkerPlugin {
 								', { type: "module" }',
 								insertLocation
 							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							dep.loc = parser.getLocation(expr);
 							parser.state.module.addPresentationalDependency(dep);
 						}
 
@@ -468,15 +611,75 @@ class WorkerPlugin {
 							parser.walkProperty(prop);
 						}
 						if (insertType === "spread") {
-							parser.walkExpression(arg2);
+							parser.walkExpression(/** @type {Expression} */ (arg2));
 						}
 
 						return true;
 					};
+
 					/**
+					 * Handles a matched `addModule(...)` worklet expression.
+					 * @param {CallExpression} expr expression
+					 * @returns {boolean | void} true when handled
+					 */
+					const handleNewWorklet = (expr) => {
+						const parsedUrl = resolveWorkerUrl(expr);
+						if (!parsedUrl) return;
+						const { url } = parsedUrl;
+
+						const entryOptions = parseEntryOptions(expr);
+						if (entryOptions === false) return false;
+
+						const block = new AsyncDependenciesBlock({
+							name: entryOptions.name,
+							circular: false,
+							entryOptions: {
+								// A module worklet links its split chunks via native `import`
+								// (resolved by `addModule`), so it keeps the module chunk
+								// loading. A script worklet can't load chunks at runtime, so its
+								// chunks use import-scripts and are pre-added from the calling scope.
+								chunkLoading: this._module
+									? this._chunkLoading
+									: "import-scripts",
+								wasmLoading: false,
+								...entryOptions,
+								worker: true,
+								// `addModule` always loads the chunk as a module, so its
+								// auto public-path can read `import.meta.url` (no shim needed).
+								worklet: true
+							}
+						});
+						block.loc = parser.getLocation(expr);
+						// The dependency rewrites the call site: the fast path swaps the URL
+						// argument directly, the multi-chunk path wraps it in a bootstrap.
+						const dep = new WorkletDependency(
+							url,
+							[
+								/** @type {Range} */ (expr.range)[0],
+								/** @type {Range} */ (expr.range)[0]
+							],
+							[
+								/** @type {Range} */ (expr.callee.range)[1],
+								/** @type {Range} */ (expr.range)[1]
+							],
+							{ publicPath: this._workerPublicPath }
+						);
+						dep.loc = parser.getLocation(expr);
+						block.addDependency(dep);
+						parser.state.module.addBlock(block);
+
+						parser.walkExpression(expr.callee);
+
+						return true;
+					};
+
+					/**
+					 * Registers the parser hooks matching a single syntax item.
 					 * @param {string} item item
+					 * @param {(expr: CallExpression, isGlobalWorker?: boolean) => boolean | void} handle handler invoked on a match
+					 * @param {symbol} specifierTag tag used for `*variable` syntax
 					 */
-					const processItem = (item) => {
+					const processItem = (item, handle, specifierTag) => {
 						if (
 							item.startsWith("*") &&
 							item.includes(".") &&
@@ -493,28 +696,26 @@ class WorkerPlugin {
 										decl.id.type === "Identifier" &&
 										decl.id.name === pattern
 									) {
-										parser.tagVariable(decl.id.name, WorkerSpecifierTag);
+										parser.tagVariable(decl.id.name, specifierTag);
 										return true;
 									}
 								}
 							);
 							parser.hooks.pattern.for(pattern).tap(PLUGIN_NAME, (pattern) => {
-								parser.tagVariable(pattern.name, WorkerSpecifierTag);
+								parser.tagVariable(pattern.name, specifierTag);
 								return true;
 							});
 							parser.hooks.callMemberChain
-								.for(WorkerSpecifierTag)
+								.for(specifierTag)
 								.tap(PLUGIN_NAME, (expression, members) => {
 									if (itemMembers !== members.join(".")) {
 										return;
 									}
 
-									return handleNewWorker(expression);
+									return handle(expression);
 								});
 						} else if (item.endsWith("()")) {
-							parser.hooks.call
-								.for(item.slice(0, -2))
-								.tap(PLUGIN_NAME, handleNewWorker);
+							parser.hooks.call.for(item.slice(0, -2)).tap(PLUGIN_NAME, handle);
 						} else {
 							const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
 							if (match) {
@@ -534,21 +735,70 @@ class WorkerPlugin {
 										) {
 											return;
 										}
-										return handleNewWorker(expr);
+										return handle(expr);
 									});
 							} else {
-								parser.hooks.new.for(item).tap(PLUGIN_NAME, handleNewWorker);
+								parser.hooks.new
+									.for(item)
+									.tap(PLUGIN_NAME, (expr) => handle(expr, item === "Worker"));
 							}
 						}
 					};
-					for (const item of options) {
-						if (item === "...") {
-							for (const itemFromDefault of DEFAULT_SYNTAX) {
-								processItem(itemFromDefault);
+
+					/**
+					 * Expands and registers a syntax list.
+					 * @param {string[]} syntaxList syntax list (may contain "...")
+					 * @param {string[]} defaultSyntax default syntax used for "..."
+					 * @param {(expr: CallExpression, isGlobalWorker?: boolean) => boolean | void} handle handler
+					 * @param {symbol} specifierTag tag used for `*variable` syntax
+					 */
+					const processList = (
+						syntaxList,
+						defaultSyntax,
+						handle,
+						specifierTag
+					) => {
+						for (const item of syntaxList) {
+							if (item === "...") {
+								for (const itemFromDefault of defaultSyntax) {
+									processItem(itemFromDefault, handle, specifierTag);
+								}
+							} else {
+								processItem(item, handle, specifierTag);
 							}
-						} else {
-							processItem(item);
 						}
+					};
+
+					if (parserOptions.worker !== false) {
+						const workerSyntax = !Array.isArray(parserOptions.worker)
+							? ["..."]
+							: parserOptions.worker;
+						processList(
+							workerSyntax,
+							WORKER_DEFAULT_SYNTAX,
+							handleNewWorker,
+							WorkerSpecifierTag
+						);
+					}
+
+					// Worklet parsing is opt-in: unset falls back to the `futureDefaults`
+					// default, `false` disables it. It is not defaulted in
+					// `config/defaults.js` because that would splice into the `"..."`
+					// merge sentinel of a user-provided list.
+					const workletOption =
+						parserOptions.worklet === undefined
+							? this._workletDefault
+							: parserOptions.worklet;
+					if (workletOption) {
+						const workletSyntax = !Array.isArray(workletOption)
+							? ["..."]
+							: workletOption;
+						processList(
+							workletSyntax,
+							WORKLET_DEFAULT_SYNTAX,
+							handleNewWorklet,
+							WorkletSpecifierTag
+						);
 					}
 				};
 				normalModuleFactory.hooks.parser
@@ -562,4 +812,4 @@ class WorkerPlugin {
 	}
 }
 
-module.exports = WorkerPlugin;
+module.exports = WorkerAndWorkletPlugin;