webpack 5.97.1 → 5.104.1

package/lib/dependencies/RequireContextPlugin.js

@@ -57,8 +57,9 @@ class RequireContextPlugin {
 					if (
 						parserOptions.requireContext !== undefined &&
 						!parserOptions.requireContext
-					)
+					) {
 						return;
+					}
 
 					new RequireContextDependencyParserPlugin().apply(parser);
 				};
@@ -80,7 +81,8 @@ class RequireContextPlugin {
 							cachedSetProperty(
 								options.resolveOptions || EMPTY_RESOLVE_OPTIONS,
 								"dependencyType",
-								/** @type {string} */ (options.category)
+								/** @type {string} */
+								(options.category)
 							)
 						).options;
 
@@ -160,4 +162,5 @@ class RequireContextPlugin {
 		);
 	}
 }
+
 module.exports = RequireContextPlugin;

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -8,13 +8,13 @@
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
+/** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 
 class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
 	/**
-	 * @param {ChunkGroupOptions & { entryOptions?: TODO }} chunkName chunk name
-	 * @param {DependencyLocation} loc location info
+	 * @param {GroupOptions | null} chunkName chunk name
+	 * @param {(DependencyLocation | null)=} loc location info
 	 */
 	constructor(chunkName, loc) {
 		super(chunkName, loc, null);

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

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

package/lib/dependencies/RequireEnsurePlugin.js

@@ -5,11 +5,6 @@
 
 "use strict";
 
-const RequireEnsureDependency = require("./RequireEnsureDependency");
-const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
-
-const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");
-
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC
@@ -18,6 +13,9 @@ const {
 	evaluateToString,
 	toConstantDependency
 } = require("../javascript/JavascriptParserHelpers");
+const RequireEnsureDependenciesBlockParserPlugin = require("./RequireEnsureDependenciesBlockParserPlugin");
+const RequireEnsureDependency = require("./RequireEnsureDependency");
+const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
 
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
@@ -58,8 +56,9 @@ class RequireEnsurePlugin {
 					if (
 						parserOptions.requireEnsure !== undefined &&
 						!parserOptions.requireEnsure
-					)
+					) {
 						return;
+					}
 
 					new RequireEnsureDependenciesBlockParserPlugin().apply(parser);
 					parser.hooks.evaluateTypeof
@@ -83,4 +82,5 @@ class RequireEnsurePlugin {
 		);
 	}
 }
+
 module.exports = RequireEnsurePlugin;

package/lib/dependencies/RequireIncludeDependency.js

@@ -11,7 +11,7 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @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 */
@@ -32,7 +32,7 @@ class RequireIncludeDependency 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/RequireIncludeDependencyParserPlugin.js

@@ -17,6 +17,8 @@ const RequireIncludeDependency = require("./RequireIncludeDependency");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "RequireIncludeDependencyParserPlugin";
+
 module.exports = class RequireIncludeDependencyParserPlugin {
 	/**
 	 * @param {boolean} warn true: warn about deprecation, false: don't warn
@@ -31,32 +33,31 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 	 */
 	apply(parser) {
 		const { warn } = this;
-		parser.hooks.call
-			.for("require.include")
-			.tap("RequireIncludeDependencyParserPlugin", expr => {
-				if (expr.arguments.length !== 1) return;
-				const param = parser.evaluateExpression(expr.arguments[0]);
-				if (!param.isString()) return;
+		parser.hooks.call.for("require.include").tap(PLUGIN_NAME, (expr) => {
+			if (expr.arguments.length !== 1) return;
+			const param = parser.evaluateExpression(expr.arguments[0]);
+			if (!param.isString()) return;
 
-				if (warn) {
-					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(
-							/** @type {DependencyLocation} */ (expr.loc)
-						)
-					);
-				}
-
-				const dep = new RequireIncludeDependency(
-					/** @type {string} */ (param.string),
-					/** @type {Range} */ (expr.range)
+			if (warn) {
+				parser.state.module.addWarning(
+					new RequireIncludeDeprecationWarning(
+						/** @type {DependencyLocation} */
+						(expr.loc)
+					)
 				);
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				parser.state.current.addDependency(dep);
-				return true;
-			});
+			}
+
+			const dep = new RequireIncludeDependency(
+				/** @type {string} */ (param.string),
+				/** @type {Range} */ (expr.range)
+			);
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			parser.state.current.addDependency(dep);
+			return true;
+		});
 		parser.hooks.evaluateTypeof
 			.for("require.include")
-			.tap("RequireIncludePlugin", expr => {
+			.tap(PLUGIN_NAME, (expr) => {
 				if (warn) {
 					parser.state.module.addWarning(
 						new RequireIncludeDeprecationWarning(
@@ -66,18 +67,16 @@ module.exports = class RequireIncludeDependencyParserPlugin {
 				}
 				return evaluateToString("function")(expr);
 			});
-		parser.hooks.typeof
-			.for("require.include")
-			.tap("RequireIncludePlugin", expr => {
-				if (warn) {
-					parser.state.module.addWarning(
-						new RequireIncludeDeprecationWarning(
-							/** @type {DependencyLocation} */ (expr.loc)
-						)
-					);
-				}
-				return toConstantDependency(parser, JSON.stringify("function"))(expr);
-			});
+		parser.hooks.typeof.for("require.include").tap(PLUGIN_NAME, (expr) => {
+			if (warn) {
+				parser.state.module.addWarning(
+					new RequireIncludeDeprecationWarning(
+						/** @type {DependencyLocation} */ (expr.loc)
+					)
+				);
+			}
+			return toConstantDependency(parser, JSON.stringify("function"))(expr);
+		});
 	}
 };
 

package/lib/dependencies/RequireIncludePlugin.js

@@ -59,4 +59,5 @@ class RequireIncludePlugin {
 		);
 	}
 }
+
 module.exports = RequireIncludePlugin;

package/lib/dependencies/RequireResolveContextDependency.js

@@ -19,7 +19,7 @@ class RequireResolveContextDependency extends ContextDependency {
 	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 * @param {Range} valueRange value range
-	 * @param {TODO} context context
+	 * @param {string=} context context
 	 */
 	constructor(options, range, valueRange, context) {
 		super(options, context);

package/lib/dependencies/RequireResolveDependency.js

@@ -10,7 +10,7 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 const ModuleDependencyAsId = require("./ModuleDependencyTemplateAsId");
 
-/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -19,7 +19,7 @@ class RequireResolveDependency extends ModuleDependency {
 	/**
 	 * @param {string} request the request string
 	 * @param {Range} range location in source code
-	 * @param {string} [context] context
+	 * @param {string=} context context
 	 */
 	constructor(request, range, context) {
 		super(request);
@@ -40,7 +40,7 @@ class RequireResolveDependency 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/RuntimeRequirementsDependency.js

@@ -9,18 +9,17 @@ const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("./NullDependency").RawRuntimeRequirements} RawRuntimeRequirements */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 class RuntimeRequirementsDependency extends NullDependency {
 	/**
-	 * @param {string[]} runtimeRequirements runtime requirements
+	 * @param {RawRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
 		super();
@@ -36,7 +35,7 @@ class RuntimeRequirementsDependency extends NullDependency {
 	 */
 	updateHash(hash, context) {
 		if (this._hashUpdate === undefined) {
-			this._hashUpdate = `${Array.from(this.runtimeRequirements).join()}`;
+			this._hashUpdate = `${[...this.runtimeRequirements].join()}`;
 		}
 		hash.update(this._hashUpdate);
 	}

package/lib/dependencies/StaticExportsDependency.js

@@ -8,18 +8,16 @@
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Dependency").ExportSpec} ExportSpec */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
+
+/** @typedef {string[] | true} Exports */
 
 class StaticExportsDependency extends NullDependency {
 	/**
-	 * @param {string[] | true} exports export names
+	 * @param {Exports} exports export names
 	 * @param {boolean} canMangle true, if mangling exports names is allowed
 	 */
 	constructor(exports, canMangle) {

package/lib/dependencies/SystemPlugin.js

@@ -46,7 +46,7 @@ class SystemPlugin {
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.system)
-					.tap(PLUGIN_NAME, (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, _set) => {
 						compilation.addRuntimeModule(chunk, new SystemRuntimeModule());
 					});
 
@@ -63,7 +63,7 @@ class SystemPlugin {
 					/**
 					 * @param {string} name name
 					 */
-					const setNotSupported = name => {
+					const setNotSupported = (name) => {
 						parser.hooks.evaluateTypeof
 							.for(name)
 							.tap(PLUGIN_NAME, evaluateToString("undefined"));
@@ -101,7 +101,7 @@ class SystemPlugin {
 					setNotSupported("System.get");
 					setNotSupported("System.register");
 
-					parser.hooks.expression.for("System").tap(PLUGIN_NAME, expr => {
+					parser.hooks.expression.for("System").tap(PLUGIN_NAME, (expr) => {
 						const dep = new ConstDependency(
 							RuntimeGlobals.system,
 							/** @type {Range} */ (expr.range),
@@ -112,7 +112,7 @@ class SystemPlugin {
 						return true;
 					});
 
-					parser.hooks.call.for("System.import").tap(PLUGIN_NAME, expr => {
+					parser.hooks.call.for("System.import").tap(PLUGIN_NAME, (expr) => {
 						parser.state.module.addWarning(
 							new SystemImportDeprecationWarning(
 								/** @type {DependencyLocation} */ (expr.loc)

package/lib/dependencies/URLContextDependency.js

@@ -0,0 +1,65 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ContextDependency = require("./ContextDependency");
+const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
+
+/** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
+
+class URLContextDependency extends ContextDependency {
+	/**
+	 * @param {ContextDependencyOptions} options options
+	 * @param {Range} range range
+	 * @param {Range} valueRange value range
+	 */
+	constructor(options, range, valueRange) {
+		super(options);
+		this.range = range;
+		this.valueRange = valueRange;
+	}
+
+	get type() {
+		return "new URL() context";
+	}
+
+	get category() {
+		return "url";
+	}
+
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		const { write } = context;
+		write(this.valueRange);
+		super.serialize(context);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		const { read } = context;
+		this.valueRange = read();
+		super.deserialize(context);
+	}
+}
+
+makeSerializable(
+	URLContextDependency,
+	"webpack/lib/dependencies/URLContextDependency"
+);
+
+URLContextDependency.Template = ContextDependencyTemplateAsRequireCall;
+
+module.exports = URLContextDependency;

package/lib/dependencies/URLDependency.js

@@ -15,20 +15,15 @@ const memoize = require("../util/memoize");
 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("../optimize/InnerGraph").UsedByExports} UsedByExports */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 const getIgnoredRawDataUrlModule = memoize(
 	() => new RawDataUrlModule("data:,", "ignored-asset", "(ignored asset)")
@@ -46,7 +41,7 @@ class URLDependency extends ModuleDependency {
 		this.range = range;
 		this.outerRange = outerRange;
 		this.relative = relative || false;
-		/** @type {Set<string> | boolean | undefined} */
+		/** @type {UsedByExports | undefined} */
 		this.usedByExports = undefined;
 	}
 
@@ -72,7 +67,7 @@ class URLDependency extends ModuleDependency {
 
 	/**
 	 * @param {string} context context directory
-	 * @returns {Module | null} a module
+	 * @returns {Module} ignored module
 	 */
 	createIgnoredModule(context) {
 		return getIgnoredRawDataUrlModule();