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

package/lib/dependencies/CommonJsRequireDependency.js

@@ -6,29 +6,38 @@
 "use strict";
 
 const Dependency = require("../Dependency");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const {
+	getDependencyUsedByExportsCondition
+} = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
-const memoize = require("../util/memoize");
 const {
 	ESM_MODULE_EXPORTS_NAME,
 	getRequireEsmModuleExportsAccess,
 	isRequireEsmModuleExportsModule
 } = require("./CommonJsDependencyHelpers");
+const HarmonyImportGuard = require("./HarmonyImportGuard");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./HarmonyImportGuard").DependencyGuard} DependencyGuard */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined]>} ObjectSerializerContext */
-
-const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import ConcatenationScope from "../ConcatenationScope" */
+/**
+ * @import {
+ * 	GetConditionFn,
+ * 	RawReferencedExports,
+ * 	ReferencedExports
+ * } from "../Dependency"
+ */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import { UsedByExports } from "../optimize/InnerGraph" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import { DependencyGuard } from "./HarmonyImportGuard" */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectSerializerContext */
 
 /**
  * Trims a member-access path at the first segment that is definitively not a
@@ -77,6 +86,13 @@ class CommonJsRequireDependency extends ModuleDependency {
 		this.valueRange = valueRange;
 		/** @type {DependencyGuard[] | undefined} */
 		this.branchGuards = undefined;
+		/** @type {UsedByExports | undefined} */
+		this.usedByExports = undefined;
+		/** @type {boolean} */
+		this._canConcatenate = false;
+		// `new require(...)`; see the template for the return-value rule
+		/** @type {boolean} */
+		this.callNew = false;
 	}
 
 	get type() {
@@ -87,16 +103,57 @@ class CommonJsRequireDependency extends ModuleDependency {
 		return "commonjs";
 	}
 
+	/**
+	 * Whether this require only evaluates the module (no exports read).
+	 * @returns {boolean} true when referencedExports is an empty list
+	 */
+	isEvaluationOnly() {
+		return (
+			Array.isArray(this.referencedExports) &&
+			this.referencedExports.length === 0
+		);
+	}
+
 	/**
 	 * Returns function to determine if the connection is active.
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
 	 */
 	getCondition(moduleGraph) {
+		const usedByExportsCondition =
+			this.usedByExports !== undefined
+				? getDependencyUsedByExportsCondition(this, moduleGraph)
+				: null;
+		if (usedByExportsCondition === false) return false;
 		const guards = this.branchGuards;
-		if (guards === undefined) return null;
-		return (connection, runtime) =>
-			!getHarmonyImportGuard().isDeadByGuards(guards, moduleGraph, runtime);
+		const evaluationOnly = this.isEvaluationOnly();
+		if (
+			usedByExportsCondition === null &&
+			guards === undefined &&
+			!evaluationOnly
+		) {
+			return null;
+		}
+		return (connection, runtime) => {
+			if (
+				usedByExportsCondition !== null &&
+				usedByExportsCondition(connection, runtime) === false
+			) {
+				return false;
+			}
+			if (
+				guards !== undefined &&
+				HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+			) {
+				return false;
+			}
+			if (evaluationOnly) {
+				const refModule = connection.resolvedModule;
+				if (!refModule) return true;
+				return refModule.getSideEffectsConnectionState(moduleGraph);
+			}
+			return true;
+		};
 	}
 
 	/**
@@ -107,6 +164,16 @@ class CommonJsRequireDependency extends ModuleDependency {
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		const importedModule = moduleGraph.getModule(this);
+		if (this.isEvaluationOnly()) {
+			// Active `require(esm)` with side effects still unwraps `module.exports`.
+			if (
+				importedModule &&
+				isRequireEsmModuleExportsModule(importedModule, moduleGraph)
+			) {
+				return [{ name: [ESM_MODULE_EXPORTS_NAME], canInline: false }];
+			}
+			return Dependency.NO_EXPORTS_REFERENCED;
+		}
 		if (
 			importedModule &&
 			isRequireEsmModuleExportsModule(importedModule, moduleGraph)
@@ -126,6 +193,28 @@ class CommonJsRequireDependency extends ModuleDependency {
 		}));
 	}
 
+	/**
+	 * Returns true if this dependency can be concatenated
+	 * @param {boolean} concatenateCommonJsModules whether optimization.concatenateModules.commonjs is enabled
+	 * @returns {boolean} true if this dependency can be concatenated
+	 */
+	canConcatenate(concatenateCommonJsModules) {
+		return concatenateCommonJsModules && this._canConcatenate;
+	}
+
+	/**
+	 * @param {ModuleGraphConnection} connection the active connection of this dependency
+	 * @param {ConcatenationScope} concatenationScope the concatenation scope
+	 * @returns {boolean} true when the call becomes a module reference
+	 */
+	rendersAsConcatenatedReference(connection, concatenationScope) {
+		return (
+			this._canConcatenate &&
+			this.valueRange !== undefined &&
+			concatenationScope.isModuleInScope(connection.module)
+		);
+	}
+
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
@@ -134,7 +223,10 @@ class CommonJsRequireDependency extends ModuleDependency {
 		context
 			.write(this.referencedExports)
 			.write(this.valueRange)
-			.write(this.branchGuards);
+			.write(this.branchGuards)
+			.write(this._canConcatenate)
+			.write(this.callNew)
+			.write(this.usedByExports);
 		super.serialize(context);
 	}
 
@@ -148,7 +240,13 @@ class CommonJsRequireDependency extends ModuleDependency {
 		this.valueRange = c1.read();
 		const c2 = c1.rest;
 		this.branchGuards = c2.read();
-		super.deserialize(c2.rest);
+		const c3 = c2.rest;
+		this._canConcatenate = c3.read();
+		const c4 = c3.rest;
+		this.callNew = c4.read();
+		const c5 = c4.rest;
+		this.usedByExports = c5.read();
+		super.deserialize(c5.rest);
 	}
 }
 
@@ -162,17 +260,62 @@ CommonJsRequireDependency.Template = class CommonJsRequireDependencyTemplate ext
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtime }
-	) {
+	apply(dependency, source, templateContext) {
+		const {
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			runtime,
+			concatenationScope
+		} = templateContext;
 		const dep = /** @type {CommonJsRequireDependency} */ (dependency);
 		if (!dep.range) return;
 		const connection = moduleGraph.getConnection(dep);
-		// Dead branch: module is excluded and has no id; code is never executed.
 		if (connection && !connection.isTargetActive(runtime)) {
-			source.replace(dep.range[0], dep.range[1] - 1, "null /* dead branch */");
+			const guards = dep.branchGuards;
+			if (
+				guards !== undefined &&
+				HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+			) {
+				// Dead branch: module is excluded and has no id; code is never executed.
+				source.replace(
+					dep.range[0],
+					dep.range[1] - 1,
+					"null /* dead branch */"
+				);
+				return;
+			}
+			// Unused side-effect-free require: drop the whole call expression.
+			if (!dep.valueRange) return;
+			source.replace(dep.valueRange[0], dep.valueRange[1] - 1, "0");
+			return;
+		}
+		if (
+			connection &&
+			concatenationScope !== undefined &&
+			dep.rendersAsConcatenatedReference(connection, concatenationScope)
+		) {
+			const valueRange = /** @type {Range} */ (dep.valueRange);
+			let content = concatenationScope.createModuleReference(
+				connection.module,
+				{
+					// `require(esm)` unwraps the "module.exports" export
+					ids: isRequireEsmModuleExportsModule(connection.module, moduleGraph)
+						? [ESM_MODULE_EXPORTS_NAME]
+						: undefined,
+					asiSafe: true,
+					moduleExportsAccess: true
+				}
+			);
+			// replacing the call drops the `new`, so apply the `new` return-value rule
+			// here: object or function passes through, anything else gets a fresh instance
+			if (dep.callNew) {
+				templateContext.runtimeRequirements.add(
+					RuntimeGlobals.constructRequire
+				);
+				content = `${RuntimeGlobals.constructRequire}(${content})`;
+			}
+			source.replace(valueRange[0], valueRange[1] - 1, content);
 			return;
 		}
 		const importedModule = /** @type {Module} */ (moduleGraph.getModule(dep));

package/lib/dependencies/CommonJsSelfReferenceDependency.js

@@ -9,18 +9,27 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const { equals } = require("../util/ArrayHelpers");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
-const { getConcatenatedExportAccess } = require("./CommonJsDependencyHelpers");
+const { isWorkerEntryThis } = require("./CommonJsDependencyHelpers");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
+/** @import { ReplaceSource } from "webpack-sources" */
+/**
+ * @import Dependency, {
+ * 	ReferencedExports,
+ * 	UpdateHashContext,
+ * 	ExportInfoName
+ * } from "../Dependency"
+ */
+/** @import Hash from "../util/Hash" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/**
+ * @import {
+ * 	CommonJSDependencyBaseKeywords
+ * } from "./CommonJsDependencyHelpers"
+ */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, CommonJSDependencyBaseKeywords, ExportInfoName[], boolean]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, CommonJSDependencyBaseKeywords, ExportInfoName[], boolean]>} ObjectSerializerContext */
 
@@ -51,6 +60,15 @@ class CommonJsSelfReferenceDependency extends NullDependency {
 		return "self";
 	}
 
+	/**
+	 * Returns true if this dependency can be concatenated
+	 * @param {boolean} concatenateCommonJsModules whether optimization.concatenateModules.commonjs is enabled
+	 * @returns {boolean} true if this dependency can be concatenated
+	 */
+	canConcatenate(concatenateCommonJsModules) {
+		return concatenateCommonJsModules;
+	}
+
 	/**
 	 * Returns an identifier to merge equal requests.
 	 * @returns {string | null} an identifier to merge equal requests
@@ -69,6 +87,26 @@ class CommonJsSelfReferenceDependency extends NullDependency {
 		return [this.call ? this.names.slice(0, -1) : this.names];
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		// a classic worker entry generates `this` as the global scope, so it must
+		// not share one code generation with a runtime that generates it as exports
+		if (this.base !== "this") return;
+		const { chunkGraph, runtime, runtimeTemplate } = context;
+		const module = chunkGraph.moduleGraph.getParentModule(this);
+		hash.update(
+			module !== undefined &&
+				isWorkerEntryThis(module, chunkGraph, runtime, runtimeTemplate)
+				? "worker global"
+				: "exports"
+		);
+	}
+
 	/**
 	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
@@ -119,16 +157,21 @@ CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependency
 		{
 			module,
 			moduleGraph,
+			chunkGraph,
 			runtime,
 			runtimeRequirements,
-			initFragments,
-			concatenationScope
+			runtimeTemplate
 		}
 	) {
 		const dep = /** @type {CommonJsSelfReferenceDependency} */ (dependency);
+		// a classic worker entry reads its global scope, not an export, so the
+		// names stay as written
+		const isWorkerEntry =
+			dep.base === "this" &&
+			isWorkerEntryThis(module, chunkGraph, runtime, runtimeTemplate);
 		// CJS exports are never inlined
 		const used =
-			dep.names.length === 0
+			isWorkerEntry || dep.names.length === 0
 				? dep.names
 				: /** @type {string | string[] | false} */ (
 						moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime)
@@ -139,29 +182,6 @@ CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependency
 			);
 		}
 
-		if (concatenationScope) {
-			// eligibility (non-empty names, exports/module.exports base) is enforced
-			// by JavascriptGenerator.getConcatenationBailoutReason
-			if (
-				dep.names.length === 0 ||
-				(dep.base !== "exports" && dep.base !== "module.exports")
-			) {
-				throw new Error(
-					`Unsupported self-reference ${dep.base} in concatenated CommonJS module`
-				);
-			}
-			source.replace(
-				dep.range[0],
-				dep.range[1] - 1,
-				getConcatenatedExportAccess(
-					concatenationScope,
-					initFragments,
-					dep.names
-				)
-			);
-			return;
-		}
-
 		/** @type {string} */
 		let base;
 		switch (dep.base) {
@@ -174,8 +194,13 @@ CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependency
 				base = `${module.moduleArgument}.exports`;
 				break;
 			case "this":
-				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-				base = "this";
+				if (isWorkerEntry) {
+					runtimeRequirements.add(RuntimeGlobals.global);
+					base = RuntimeGlobals.global;
+				} else {
+					runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+					base = "this";
+				}
 				break;
 			default:
 				throw new Error(`Unsupported base ${dep.base}`);

package/lib/dependencies/ConstDependency.js

@@ -8,17 +8,16 @@
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @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("../ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { RawRuntimeRequirements } from "./NullDependency" */
+/** @import Dependency, { UpdateHashContext } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { ConnectionState } from "../ModuleGraphConnection" */
+/** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, number | Range, Set<string> | null]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, number | Range, Set<string> | null]>} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
+/** @import Hash from "../util/Hash" */
 
 class ConstDependency extends NullDependency {
 	/**

package/lib/dependencies/ContextDependency.js

@@ -10,18 +10,22 @@ const DependencyTemplate = require("../DependencyTemplate");
 const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
 
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-
 const getCriticalDependencyWarning = memoize(() =>
 	require("./CriticalDependencyWarning")
 );
 
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import { ContextOptions } from "../ContextModule" */
+/** @import { TRANSITIVE } from "../Dependency" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import WebpackError from "../errors/WebpackError" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+
 /** @typedef {ContextOptions & { request: string }} ContextDependencyOptions */
 
 /** @typedef {{ value: string, range: Range }[]} Replaces */

package/lib/dependencies/ContextDependencyHelpers.js

@@ -7,15 +7,20 @@
 
 const { parseResource } = require("../util/identifier");
 
-/** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("./ContextDependency")} ContextDependency */
-/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
-/** @typedef {import("./ContextDependency").Replaces} Replaces */
+/** @import { Expression } from "estree" */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
+/** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+/**
+ * @import ContextDependency, {
+ * 	ContextDependencyOptions,
+ * 	Replaces
+ * } from "./ContextDependency"
+ */
 
 /**
  * Escapes regular expression metacharacters

package/lib/dependencies/ContextDependencyTemplateAsId.js

@@ -7,10 +7,10 @@
 
 const ContextDependency = require("./ContextDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import Dependency from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 
 class ContextDependencyTemplateAsId extends ContextDependency.Template {
 	/**

package/lib/dependencies/ContextDependencyTemplateAsRequireCall.js

@@ -7,10 +7,10 @@
 
 const ContextDependency = require("./ContextDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import Dependency from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 
 class ContextDependencyTemplateAsRequireCall
 	extends ContextDependency.Template
@@ -22,11 +22,9 @@ class ContextDependencyTemplateAsRequireCall
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(
-		dependency,
-		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements }
-	) {
+	apply(dependency, source, templateContext) {
+		const { runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements } =
+			templateContext;
 		const dep = /** @type {ContextDependency} */ (dependency);
 		let moduleExports = runtimeTemplate.moduleExports({
 			module: moduleGraph.getModule(dep),
@@ -49,8 +47,7 @@ class ContextDependencyTemplateAsRequireCall
 						source.replace(rep.range[0], rep.range[1] - 1, rep.value);
 					}
 				}
-				source.replace(dep.valueRange[1], range[1] - 1, ")");
-				source.replace(range[0], dep.valueRange[0] - 1, `${moduleExports}(`);
+				this.replaceCall(dep, source, moduleExports, templateContext);
 			} else {
 				source.replace(range[0], range[1] - 1, moduleExports);
 			}
@@ -58,6 +55,22 @@ class ContextDependencyTemplateAsRequireCall
 			source.replace(range[0], range[1] - 1, moduleExports);
 		}
 	}
+
+	/**
+	 * Rewrites the call around its request, dropping anything the original one
+	 * carried after it. Overridden where a later argument must be kept.
+	 * @param {ContextDependency} dep the dependency
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {string} moduleExports the expression the request is passed to
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	replaceCall(dep, source, moduleExports, templateContext) {
+		const range = /** @type {Range} */ (dep.range);
+		const valueRange = /** @type {Range} */ (dep.valueRange);
+		source.replace(valueRange[1], range[1] - 1, ")");
+		source.replace(range[0], valueRange[0] - 1, `${moduleExports}(`);
+	}
 }
 
 module.exports = ContextDependencyTemplateAsRequireCall;