webpack 5.59.0 → 5.94.0

package/lib/dependencies/SystemPlugin.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const WebpackError = require("../WebpackError");
 const {
@@ -16,7 +20,13 @@ const makeSerializable = require("../util/makeSerializable");
 const ConstDependency = require("./ConstDependency");
 const SystemRuntimeModule = require("./SystemRuntimeModule");
 
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "SystemPlugin";
 
 class SystemPlugin {
 	/**
@@ -26,36 +36,44 @@ class SystemPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"SystemPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.hooks.runtimeRequirementInModule
 					.for(RuntimeGlobals.system)
-					.tap("SystemPlugin", (module, set) => {
+					.tap(PLUGIN_NAME, (module, set) => {
 						set.add(RuntimeGlobals.requireScope);
 					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.system)
-					.tap("SystemPlugin", (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, set) => {
 						compilation.addRuntimeModule(chunk, new SystemRuntimeModule());
 					});
 
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
 				const handler = (parser, parserOptions) => {
 					if (parserOptions.system === undefined || !parserOptions.system) {
 						return;
 					}
 
+					/**
+					 * @param {string} name name
+					 */
 					const setNotSupported = name => {
 						parser.hooks.evaluateTypeof
 							.for(name)
-							.tap("SystemPlugin", evaluateToString("undefined"));
+							.tap(PLUGIN_NAME, evaluateToString("undefined"));
 						parser.hooks.expression
 							.for(name)
 							.tap(
-								"SystemPlugin",
+								PLUGIN_NAME,
 								expressionIsUnsupported(
 									parser,
-									name + " is not supported by webpack."
+									`${name} is not supported by webpack.`
 								)
 							);
 					};
@@ -63,43 +81,49 @@ class SystemPlugin {
 					parser.hooks.typeof
 						.for("System.import")
 						.tap(
-							"SystemPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("function"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("System.import")
-						.tap("SystemPlugin", evaluateToString("function"));
+						.tap(PLUGIN_NAME, evaluateToString("function"));
 					parser.hooks.typeof
 						.for("System")
 						.tap(
-							"SystemPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("System")
-						.tap("SystemPlugin", evaluateToString("object"));
+						.tap(PLUGIN_NAME, evaluateToString("object"));
 
 					setNotSupported("System.set");
 					setNotSupported("System.get");
 					setNotSupported("System.register");
 
-					parser.hooks.expression.for("System").tap("SystemPlugin", expr => {
-						const dep = new ConstDependency(RuntimeGlobals.system, expr.range, [
-							RuntimeGlobals.system
-						]);
-						dep.loc = expr.loc;
+					parser.hooks.expression.for("System").tap(PLUGIN_NAME, expr => {
+						const dep = new ConstDependency(
+							RuntimeGlobals.system,
+							/** @type {Range} */ (expr.range),
+							[RuntimeGlobals.system]
+						);
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						parser.state.module.addPresentationalDependency(dep);
 						return true;
 					});
 
-					parser.hooks.call.for("System.import").tap("SystemPlugin", expr => {
+					parser.hooks.call.for("System.import").tap(PLUGIN_NAME, expr => {
 						parser.state.module.addWarning(
-							new SystemImportDeprecationWarning(expr.loc)
+							new SystemImportDeprecationWarning(
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
 						);
 
 						return parser.hooks.importCall.call({
 							type: "ImportExpression",
-							source: expr.arguments[0],
+							source:
+								/** @type {import("estree").Literal} */
+								(expr.arguments[0]),
 							loc: expr.loc,
 							range: expr.range
 						});
@@ -107,17 +131,20 @@ class SystemPlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("SystemPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("SystemPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}
 }
 
 class SystemImportDeprecationWarning extends WebpackError {
+	/**
+	 * @param {DependencyLocation} loc location
+	 */
 	constructor(loc) {
 		super(
 			"System.import() is deprecated and will be removed soon. Use import() instead.\n" +

package/lib/dependencies/SystemRuntimeModule.js

@@ -15,7 +15,7 @@ class SystemRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		return Template.asString([

package/lib/dependencies/URLDependency.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const RawDataUrlModule = require("../asset/RawDataUrlModule");
 const {
 	getDependencyUsedByExportsCondition
 } = require("../optimize/InnerGraph");
@@ -16,22 +17,28 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @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 */
 
-const getRawModule = memoize(() => require("../RawModule"));
+const getIgnoredRawDataUrlModule = memoize(
+	() => new RawDataUrlModule("data:,", "ignored-asset", "(ignored asset)")
+);
 
 class URLDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
-	 * @param {[number, number]} range range of the arguments of new URL( |> ... <| )
-	 * @param {[number, number]} outerRange range of the full |> new URL(...) <|
+	 * @param {Range} range range of the arguments of new URL( |> ... <| )
+	 * @param {Range} outerRange range of the full |> new URL(...) <|
 	 * @param {boolean=} relative use relative urls instead of absolute with base uri
 	 */
 	constructor(request, range, outerRange, relative) {
@@ -39,7 +46,7 @@ class URLDependency extends ModuleDependency {
 		this.range = range;
 		this.outerRange = outerRange;
 		this.relative = relative || false;
-		/** @type {Set<string> | boolean} */
+		/** @type {Set<string> | boolean | undefined} */
 		this.usedByExports = undefined;
 	}
 
@@ -53,7 +60,7 @@ class URLDependency extends ModuleDependency {
 
 	/**
 	 * @param {ModuleGraph} moduleGraph module graph
-	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
 		return getDependencyUsedByExportsCondition(
@@ -65,18 +72,15 @@ class URLDependency extends ModuleDependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module} a module
+	 * @returns {Module | null} a module
 	 */
 	createIgnoredModule(context) {
-		const RawModule = getRawModule();
-		return new RawModule(
-			'module.exports = "data:,";',
-			`ignored-asset`,
-			`(ignored asset)`,
-			new Set([RuntimeGlobals.module])
-		);
+		return getIgnoredRawDataUrlModule();
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.outerRange);
@@ -85,6 +89,9 @@ class URLDependency extends ModuleDependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.outerRange = read();

package/lib/dependencies/URLPlugin.js

@@ -5,13 +5,30 @@
 
 "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").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 {
 	/**
@@ -19,7 +36,7 @@ class URLPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"URLPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
 				compilation.dependencyTemplates.set(
@@ -28,8 +45,30 @@ class URLPlugin {
 				);
 
 				/**
-				 * @param {JavascriptParser} parser parser
-				 * @param {object} parserOptions options
+				 * @param {NormalModule} module module
+				 * @returns {URL} file url
+				 */
+				const getUrl = module => pathToFileURL(module.resource);
+
+				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 {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
 				 */
 				const parserCallback = (parser, parserOptions) => {
 					if (parserOptions.url === false) return;
@@ -50,25 +89,71 @@ class URLPlugin {
 						)
 							return;
 
-						const chain = parser.extractMemberExpressionChain(arg2);
-
-						if (
-							chain.members.length !== 1 ||
-							chain.object.type !== "MetaProperty" ||
-							chain.object.meta.name !== "import" ||
-							chain.object.property.name !== "meta" ||
-							chain.members[0] !== "url"
-						)
-							return;
-
-						const request = parser.evaluateExpression(arg1).asString();
+						if (!isMetaUrl(parser, arg2)) return;
 
-						return request;
+						return parser.evaluateExpression(arg1).asString();
 					};
 
-					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
-					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
+					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}`,
+										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);
 
@@ -77,16 +162,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;
-						parser.state.module.addDependency(dep);
+						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;
@@ -100,12 +188,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);
 
@@ -66,7 +71,7 @@ WebpackIsIncludedDependency.Template = class WebpackIsIncludedDependencyTemplate
 					`__webpack_is_included__ ${runtimeTemplate.requestShortener.shorten(
 						dep.request
 					)}`
-			  )
+				)
 			: "";
 
 		source.replace(

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}`
 		);