webpack 5.14.0 → 5.18.0

package/lib/debug/ProfilingPlugin.js

@@ -25,6 +25,7 @@ class Profiler {
 	constructor(inspector) {
 		this.session = undefined;
 		this.inspector = inspector;
+		this._startTime = 0;
 	}
 
 	hasSession() {
@@ -44,6 +45,9 @@ class Profiler {
 			return Promise.resolve();
 		}
 
+		const hrtime = process.hrtime();
+		this._startTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
+
 		return Promise.all([
 			this.sendCommand("Profiler.setSamplingInterval", {
 				interval: 100
@@ -78,7 +82,22 @@ class Profiler {
 	}
 
 	stopProfiling() {
-		return this.sendCommand("Profiler.stop");
+		return this.sendCommand("Profiler.stop").then(({ profile }) => {
+			const hrtime = process.hrtime();
+			const endTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
+			if (profile.startTime < this._startTime || profile.endTime > endTime) {
+				// In some cases timestamps mismatch and we need to adjust them
+				// Both process.hrtime and the inspector timestamps claim to be relative
+				// to a unknown point in time. But they do not guarantee that this is the
+				// same point in time.
+				const duration = profile.endTime - profile.startTime;
+				const ownDuration = endTime - this._startTime;
+				const untracked = Math.max(0, ownDuration - duration);
+				profile.startTime = this._startTime + untracked / 2;
+				profile.endTime = endTime - untracked / 2;
+			}
+			return { profile };
+		});
 	}
 }
 

package/lib/dependencies/AMDDefineDependency.js

@@ -79,7 +79,7 @@ const DEFINITIONS = {
 	lof: {
 		definition: "var XXX, XXXfactory, XXXmodule;",
 		content:
-			"!(XXXfactory = (#), (typeof XXXfactory === 'function' ? (XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports) : XXX = XXXfactory))",
+			"!(XXXfactory = (#), (typeof XXXfactory === 'function' ? ((XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports)) : XXX = XXXfactory))",
 		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
 	},
 	laf: {

package/lib/dependencies/AMDPlugin.js

@@ -28,16 +28,14 @@ const ConstDependency = require("./ConstDependency");
 const LocalModuleDependency = require("./LocalModuleDependency");
 const UnsupportedDependency = require("./UnsupportedDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
 class AMDPlugin {
 	/**
-	 * @param {ModuleOptions} options the plugin options
 	 * @param {Record<string, any>} amdOptions the AMD options
 	 */
-	constructor(options, amdOptions) {
-		this.options = options;
+	constructor(amdOptions) {
 		this.amdOptions = amdOptions;
 	}
 
@@ -47,7 +45,6 @@ class AMDPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const options = this.options;
 		const amdOptions = this.amdOptions;
 		compiler.hooks.compilation.tap(
 			"AMDPlugin",
@@ -151,8 +148,10 @@ class AMDPlugin {
 							);
 					};
 
-					new AMDRequireDependenciesBlockParserPlugin(options).apply(parser);
-					new AMDDefineDependencyParserPlugin(options).apply(parser);
+					new AMDRequireDependenciesBlockParserPlugin(parserOptions).apply(
+						parser
+					);
+					new AMDDefineDependencyParserPlugin(parserOptions).apply(parser);
 
 					tapOptionsHooks("define.amd", "define", () => "amd");
 					tapOptionsHooks("require.amd", "require", () => ["amd"]);

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -5,7 +5,9 @@
 
 "use strict";
 
+const CommentCompilationWarning = require("../CommentCompilationWarning");
 const RuntimeGlobals = require("../RuntimeGlobals");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const {
 	evaluateToIdentifier,
 	evaluateToString,
@@ -24,7 +26,12 @@ const RequireResolveContextDependency = require("./RequireResolveContextDependen
 const RequireResolveDependency = require("./RequireResolveDependency");
 const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+
 class CommonJsImportsParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options parser options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -173,8 +180,43 @@ class CommonJsImportsParserPlugin {
 			parser.state.current.addDependency(dep);
 			return true;
 		};
-
 		const createRequireHandler = callNew => expr => {
+			if (options.commonjsMagicComments) {
+				const {
+					options: requireOptions,
+					errors: commentErrors
+				} = parser.parseCommentOptions(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 (requireOptions) {
+					if (requireOptions.webpackIgnore !== undefined) {
+						if (typeof requireOptions.webpackIgnore !== "boolean") {
+							parser.state.module.addWarning(
+								new UnsupportedFeatureWarning(
+									`\`webpackIgnore\` expected a boolean, but received: ${requireOptions.webpackIgnore}.`,
+									expr.loc
+								)
+							);
+						} else {
+							// Do not instrument `require()` if `webpackIgnore` is `true`
+							if (requireOptions.webpackIgnore) {
+								return true;
+							}
+						}
+					}
+				}
+			}
+
 			if (expr.arguments.length !== 1) return;
 			let localModule;
 			const param = parser.evaluateExpression(expr.arguments[0]);

package/lib/dependencies/CommonJsPlugin.js

@@ -31,12 +31,7 @@ const {
 const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
 
 class CommonJsPlugin {
-	constructor(options) {
-		this.options = options;
-	}
-
 	apply(compiler) {
-		const options = this.options;
 		compiler.hooks.compilation.tap(
 			"CommonJsPlugin",
 			(compilation, { contextModuleFactory, normalModuleFactory }) => {
@@ -212,7 +207,7 @@ class CommonJsPlugin {
 						evaluateToIdentifier("module.hot", "module", () => ["hot"], null)
 					);
 
-					new CommonJsImportsParserPlugin(options).apply(parser);
+					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
 					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
 						parser
 					);

package/lib/dependencies/ContextDependencyHelpers.js

@@ -8,7 +8,8 @@
 const { parseResource } = require("../util/identifier");
 
 /** @typedef {import("estree").Node} EsTreeNode */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./ContextDependency")} ContextDependency */
@@ -45,7 +46,7 @@ const splitContextFromPrefix = prefix => {
  * @param {[number, number]} range source range
  * @param {BasicEvaluatedExpression} param context param
  * @param {EsTreeNode} expr expr
- * @param {ModuleOptions} options options for context creation
+ * @param {Pick<JavascriptParserOptions, `${"expr"|"wrapped"}Context${"Critical"|"Recursive"|"RegExp"}` | "exprContextRequest">} options options for context creation
  * @param {PartialContextDependencyOptions} contextOptions options for the ContextModule
  * @param {JavascriptParser} parser the parser
  * @returns {ContextDependency} the created Dependency

package/lib/dependencies/ExportsInfoDependency.js

@@ -83,26 +83,6 @@ class ExportsInfoDependency extends NullDependency {
 		this.property = property;
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime } = context;
-		const { moduleGraph } = chunkGraph;
-		const module = moduleGraph.getParentModule(this);
-		const value = getProperty(
-			moduleGraph,
-			module,
-			this.exportName,
-			this.property,
-			runtime
-		);
-		hash.update(value === undefined ? "undefined" : JSON.stringify(value));
-	}
-
 	serialize(context) {
 		const { write } = context;
 		write(this.range);

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -18,8 +18,7 @@ const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDepe
 
 module.exports = class HarmonyExportDependencyParserPlugin {
 	constructor(options) {
-		const { module: moduleOptions } = options;
-		this.strictExportPresence = moduleOptions.strictExportPresence;
+		this.strictExportPresence = options.strictExportPresence;
 	}
 
 	apply(parser) {

package/lib/dependencies/HarmonyExportImportedSpecifierDependency.js

@@ -680,35 +680,6 @@ class HarmonyExportImportedSpecifierDependency extends HarmonyImportDependency {
 		return errors;
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime } = context;
-		super.updateHash(hash, context);
-
-		const mode = this.getMode(chunkGraph.moduleGraph, runtime);
-
-		hash.update(mode.type);
-		if (mode.items) {
-			for (const item of mode.items) {
-				hash.update(item.name);
-				hash.update(item.ids.join());
-				if (item.checked) hash.update("checked");
-			}
-		}
-		if (mode.ignored) {
-			hash.update("ignored");
-			for (const k of mode.ignored) {
-				hash.update(k);
-			}
-		}
-		hash.update(mode.name || "");
-	}
-
 	serialize(context) {
 		const { write } = context;
 

package/lib/dependencies/HarmonyImportDependency.js

@@ -196,47 +196,6 @@ class HarmonyImportDependency extends ModuleDependency {
 		}
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime, runtimeTemplate } = context;
-		const { moduleGraph } = chunkGraph;
-		super.updateHash(hash, context);
-		hash.update(`${this.sourceOrder}`);
-		const connection = moduleGraph.getConnection(this);
-		if (connection) {
-			const importedModule = connection.module;
-			if (importedModule) {
-				const parentModule = moduleGraph.getParentModule(this);
-				hash.update(
-					importedModule.getExportsType(
-						moduleGraph,
-						parentModule.buildMeta && parentModule.buildMeta.strictHarmonyModule
-					)
-				);
-				if (moduleGraph.isAsync(importedModule)) hash.update("async");
-			}
-			if (runtimeTemplate) {
-				const runtimeRequirements = new Set();
-				hash.update(
-					runtimeTemplate.runtimeConditionExpression({
-						chunkGraph,
-						runtimeCondition: filterRuntime(runtime, runtime => {
-							return connection.isTargetActive(runtime);
-						}),
-						runtime,
-						runtimeRequirements
-					})
-				);
-				for (const rr of runtimeRequirements) hash.update(rr);
-			}
-		}
-	}
-
 	serialize(context) {
 		const { write } = context;
 		write(this.sourceOrder);

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -33,9 +33,8 @@ const harmonySpecifierTag = Symbol("harmony import");
 
 module.exports = class HarmonyImportDependencyParserPlugin {
 	constructor(options) {
-		const { module: moduleOptions } = options;
-		this.strictExportPresence = moduleOptions.strictExportPresence;
-		this.strictThisContextOnImports = moduleOptions.strictThisContextOnImports;
+		this.strictExportPresence = options.strictExportPresence;
+		this.strictThisContextOnImports = options.strictThisContextOnImports;
 	}
 
 	/**

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const Dependency = require("../Dependency");
-const { UsageState } = require("../ExportsInfo");
+const { isDependencyUsedByExports } = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
@@ -84,7 +84,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getCondition(moduleGraph) {
 		return (connection, runtime) =>
-			this.checkUsedByExports(moduleGraph, runtime);
+			isDependencyUsedByExports(this, this.usedByExports, moduleGraph, runtime);
 	}
 
 	/**
@@ -95,21 +95,6 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return false;
 	}
 
-	checkUsedByExports(moduleGraph, runtime) {
-		if (this.usedByExports === false) return false;
-		if (this.usedByExports !== true && this.usedByExports !== undefined) {
-			const selfModule = moduleGraph.getParentModule(this);
-			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-			let used = false;
-			for (const exportName of this.usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-					used = true;
-			}
-			if (!used) return false;
-		}
-		return true;
-	}
-
 	/**
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph
@@ -196,25 +181,6 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return 0;
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		const { chunkGraph, runtime } = context;
-		super.updateHash(hash, context);
-		const moduleGraph = chunkGraph.moduleGraph;
-		const importedModule = moduleGraph.getModule(this);
-		const ids = this.getIds(moduleGraph);
-		hash.update(ids.join());
-		if (importedModule) {
-			const exportsInfo = moduleGraph.getExportsInfo(importedModule);
-			hash.update(`${exportsInfo.getUsedName(ids, runtime)}`);
-		}
-	}
-
 	serialize(context) {
 		const { write } = context;
 		write(this.ids);

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -103,8 +103,8 @@ class HarmonyModulesPlugin {
 						return;
 
 					new HarmonyDetectionParserPlugin(this.options).apply(parser);
-					new HarmonyImportDependencyParserPlugin(this.options).apply(parser);
-					new HarmonyExportDependencyParserPlugin(this.options).apply(parser);
+					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
+					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyTopLevelThisParserPlugin().apply(parser);
 				};
 

package/lib/dependencies/ImportPlugin.js

@@ -14,17 +14,12 @@ const ImportWeakDependency = require("./ImportWeakDependency");
 /** @typedef {import("../Compiler")} Compiler */
 
 class ImportPlugin {
-	constructor(options) {
-		this.options = options;
-	}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		const options = this.options;
 		compiler.hooks.compilation.tap(
 			"ImportPlugin",
 			(compilation, { contextModuleFactory, normalModuleFactory }) => {
@@ -68,7 +63,7 @@ class ImportPlugin {
 					if (parserOptions.import !== undefined && !parserOptions.import)
 						return;
 
-					new ImportParserPlugin(options).apply(parser);
+					new ImportParserPlugin(parserOptions).apply(parser);
 				};
 
 				normalModuleFactory.hooks.parser

package/lib/dependencies/JsonExportsDependency.js

@@ -73,7 +73,6 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	updateHash(hash, context) {
 		hash.update(this.exports ? JSON.stringify(this.exports) : "undefined");
-		super.updateHash(hash, context);
 	}
 
 	serialize(context) {

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -69,7 +69,6 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		super.updateHash(hash, context);
 		hash.update(this.decorator);
 		hash.update(`${this.allowExportsAccess}`);
 	}

package/lib/dependencies/NullDependency.js

@@ -20,14 +20,6 @@ class NullDependency extends Dependency {
 		return "null";
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {}
-
 	serialize({ write }) {
 		write(this.loc);
 	}

package/lib/dependencies/ProvidedDependency.js

@@ -51,7 +51,6 @@ class ProvidedDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		super.updateHash(hash, context);
 		hash.update(this.identifier);
 		hash.update(this.path ? this.path.join(",") : "null");
 	}

package/lib/dependencies/StaticExportsDependency.js

@@ -43,18 +43,6 @@ class StaticExportsDependency extends NullDependency {
 		};
 	}
 
-	/**
-	 * Update the hash
-	 * @param {Hash} hash hash to be updated
-	 * @param {UpdateHashContext} context context
-	 * @returns {void}
-	 */
-	updateHash(hash, context) {
-		hash.update(JSON.stringify(this.exports));
-		if (this.canMangle) hash.update("canMangle");
-		super.updateHash(hash, context);
-	}
-
 	serialize(context) {
 		const { write } = context;
 		write(this.exports);

package/lib/dependencies/SystemPlugin.js

@@ -19,10 +19,6 @@ const SystemRuntimeModule = require("./SystemRuntimeModule");
 /** @typedef {import("../Compiler")} Compiler */
 
 class SystemPlugin {
-	constructor(options) {
-		this.options = options;
-	}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance

package/lib/dependencies/URLDependency.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { isDependencyUsedByExports } = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
@@ -15,16 +16,23 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class URLDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
-	 * @param {[number, number]} range range
+	 * @param {[number, number]} range range of the arguments of new URL( |> ... <| )
+	 * @param {[number, number]} outerRange range of the full |> new URL(...) <|
 	 */
-	constructor(request, range) {
+	constructor(request, range, outerRange) {
 		super(request);
 		this.range = range;
+		this.outerRange = outerRange;
+		/** @type {Set<string> | boolean} */
+		this.usedByExports = undefined;
 	}
 
 	get type() {
@@ -34,6 +42,29 @@ class URLDependency extends ModuleDependency {
 	get category() {
 		return "url";
 	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return (connection, runtime) =>
+			isDependencyUsedByExports(this, this.usedByExports, moduleGraph, runtime);
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.outerRange);
+		write(this.usedByExports);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.outerRange = read();
+		this.usedByExports = read();
+		super.deserialize(context);
+	}
 }
 
 URLDependency.Template = class URLDependencyTemplate extends (
@@ -50,9 +81,20 @@ URLDependency.Template = class URLDependencyTemplate extends (
 			chunkGraph,
 			moduleGraph,
 			runtimeRequirements,
-			runtimeTemplate
+			runtimeTemplate,
+			runtime
 		} = templateContext;
 		const dep = /** @type {URLDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) {
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				"/* unused asset import */ undefined"
+			);
+			return;
+		}
 
 		runtimeRequirements.add(RuntimeGlobals.baseURI);
 		runtimeRequirements.add(RuntimeGlobals.require);

package/lib/dependencies/URLPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { approve } = require("../javascript/JavascriptParserHelpers");
+const InnerGraph = require("../optimize/InnerGraph");
 const URLDependency = require("./URLDependency");
 
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
@@ -32,10 +33,12 @@ class URLPlugin {
 				 */
 				const parserCallback = (parser, parserOptions) => {
 					if (parserOptions.url === false) return;
-					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
-					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
-						const expr = /** @type {NewExpressionNode} */ (_expr);
 
+					/**
+					 * @param {NewExpressionNode} expr expression
+					 * @returns {undefined | string} request
+					 */
+					const getUrlRequest = expr => {
 						if (expr.arguments.length !== 2) return;
 
 						const [arg1, arg2] = expr.arguments;
@@ -59,16 +62,39 @@ class URLPlugin {
 
 						const request = parser.evaluateExpression(arg1).asString();
 
+						return request;
+					};
+
+					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
+					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
+						const expr = /** @type {NewExpressionNode} */ (_expr);
+
+						const request = getUrlRequest(expr);
+
 						if (!request) return;
 
-						const dep = new URLDependency(request, [
-							arg1.range[0],
-							arg2.range[1]
-						]);
+						const [arg1, arg2] = expr.arguments;
+						const dep = new URLDependency(
+							request,
+							[arg1.range[0], arg2.range[1]],
+							expr.range
+						);
 						dep.loc = expr.loc;
 						parser.state.module.addDependency(dep);
+						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 						return true;
 					});
+					parser.hooks.isPure.for("NewExpression").tap("URLPlugin", _expr => {
+						const expr = /** @type {NewExpressionNode} */ (_expr);
+						const { callee } = expr;
+						if (callee.type !== "Identifier") return;
+						const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
+						if (!calleeInfo || calleeInfo.name !== "URL") return;
+
+						const request = getUrlRequest(expr);
+
+						if (request) return true;
+					});
 				};
 
 				normalModuleFactory.hooks.parser