webpack 5.106.2 → 5.107.0

package/lib/css/walkCssTokens.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { makeCacheable } = require("../util/identifier");
+
 /**
  * Defines the css token callbacks type used by this module.
  * @typedef {object} CssTokenCallbacks
@@ -161,6 +163,143 @@ const isIdentStartCodePoint = (cc) =>
 	cc === CC_LOW_LINE ||
 	cc >= 0x80;
 
+const REGEX_SINGLE_ESCAPE = /[ -,./:-@[\]^`{-~]/;
+const REGEX_EXCESSIVE_SPACES = /(^|\\+)?(\\[A-F0-9]{1,6}) (?![a-fA-F0-9 ])/g;
+const REGEX_CTRL_WHITESPACE = /[\t\n\f\r\v]/;
+const REGEX_LEADING_HYPHEN_DIGIT = /^-[-\d]/;
+const REGEX_DIGIT = /\d/;
+const CONTAINS_ESCAPE = /\\/;
+
+/**
+ * Returns escaped identifier.
+ * @param {string} str string
+ * @returns {string} escaped identifier
+ */
+const _escapeIdentifier = (str) => {
+	let output = "";
+	let counter = 0;
+
+	while (counter < str.length) {
+		const character = str.charAt(counter++);
+
+		/** @type {string} */
+		let value;
+
+		if (REGEX_CTRL_WHITESPACE.test(character)) {
+			const codePoint = character.charCodeAt(0);
+
+			value = `\\${codePoint.toString(16).toUpperCase()} `;
+		} else if (character === "\\" || REGEX_SINGLE_ESCAPE.test(character)) {
+			value = `\\${character}`;
+		} else {
+			value = character;
+		}
+
+		output += value;
+	}
+
+	const firstChar = str.charAt(0);
+
+	if (REGEX_LEADING_HYPHEN_DIGIT.test(output)) {
+		output = `\\-${output.slice(1)}`;
+	} else if (REGEX_DIGIT.test(firstChar)) {
+		output = `\\3${firstChar} ${output.slice(1)}`;
+	}
+
+	// Remove spaces after `\HEX` escapes that are not followed by a hex digit,
+	// since they’re redundant. Note that this is only possible if the escape
+	// sequence isn’t preceded by an odd number of backslashes.
+	output = output.replace(REGEX_EXCESSIVE_SPACES, ($0, $1, $2) => {
+		if ($1 && $1.length % 2) {
+			// It’s not safe to remove the space, so don’t.
+			return $0;
+		}
+
+		// Strip the space.
+		return ($1 || "") + $2;
+	});
+
+	return output;
+};
+
+/**
+ * Returns hex.
+ * @param {string} str string
+ * @returns {[string, number] | undefined} hex
+ */
+const gobbleHex = (str) => {
+	const lower = str.toLowerCase();
+	let hex = "";
+	let spaceTerminated = false;
+
+	for (let i = 0; i < 6 && lower[i] !== undefined; i++) {
+		const code = lower.charCodeAt(i);
+		// check to see if we are dealing with a valid hex char [a-f|0-9]
+		const valid = (code >= 97 && code <= 102) || (code >= 48 && code <= 57);
+		// https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
+		spaceTerminated = code === 32;
+		if (!valid) break;
+		hex += lower[i];
+	}
+
+	if (hex.length === 0) return undefined;
+
+	const codePoint = Number.parseInt(hex, 16);
+	const isSurrogate = codePoint >= 0xd800 && codePoint <= 0xdfff;
+
+	// Add special case for
+	// "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
+	// https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
+	if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10ffff) {
+		return ["�", hex.length + (spaceTerminated ? 1 : 0)];
+	}
+
+	return [
+		String.fromCodePoint(codePoint),
+		hex.length + (spaceTerminated ? 1 : 0)
+	];
+};
+
+/**
+ * Unescape identifier.
+ * @param {string} str string
+ * @returns {string} unescaped string
+ */
+const _unescapeIdentifier = (str) => {
+	const needToProcess = CONTAINS_ESCAPE.test(str);
+	if (!needToProcess) return str;
+	let ret = "";
+	for (let i = 0; i < str.length; i++) {
+		if (str[i] === "\\") {
+			const gobbled = gobbleHex(str.slice(i + 1, i + 7));
+			if (gobbled !== undefined) {
+				ret += gobbled[0];
+				i += gobbled[1];
+				continue;
+			}
+			// Retain a pair of \\ if double escaped `\\\\`
+			// https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
+			if (str[i + 1] === "\\") {
+				ret += "\\";
+				i += 1;
+				continue;
+			}
+			// if \\ is at the end of the string retain it
+			// https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
+			if (str.length === i + 1) {
+				ret += str[i];
+			}
+			continue;
+		}
+		ret += str[i];
+	}
+
+	return ret;
+};
+
+const escapeIdentifier = makeCacheable(_escapeIdentifier);
+const unescapeIdentifier = makeCacheable(_unescapeIdentifier);
+
 /** @type {CharHandler} */
 const consumeDelimToken = (input, pos, callbacks) => {
 	// Return a <delim-token> with its value set to the current input code point.
@@ -1632,11 +1771,11 @@ const eatImageSetStrings = (input, pos, cbs) => {
  * @param {string} input input
  * @param {number} pos position
  * @param {CssTokenCallbacks} cbs callbacks
- * @returns {[[number, number, number, number] | undefined, [number, number] | undefined, [number, number] | undefined, [number, number] | undefined]} positions of top level tokens
+ * @returns {[[number, number, number, number, boolean?] | undefined, [number, number] | undefined, [number, number] | undefined, [number, number] | undefined]} positions of top level tokens — the URL tuple's optional 5th element is `true` when the URL was given as an identifier (CSS Modules `@value` reference)
  */
 const eatImportTokens = (input, pos, cbs) => {
 	const result =
-		/** @type {[[number, number, number, number] | undefined, [number, number] | undefined, [number, number] | undefined, [number, number] | undefined]} */
+		/** @type {[[number, number, number, number, boolean?] | undefined, [number, number] | undefined, [number, number] | undefined, [number, number] | undefined]} */
 		(Array.from({ length: 4 }));
 
 	/** @type {0 | 1 | 2 | undefined} */
@@ -1740,6 +1879,11 @@ const eatImportTokens = (input, pos, cbs) => {
 				if (name === "layer") {
 					result[1] = [start, end];
 					scope = undefined;
+				} else if (result[0] === undefined) {
+					// Capture as URL identifier (e.g. `@import myValue;` where
+					// `myValue` is a CSS Modules `@value` definition).
+					result[0] = [start, end, start, end, true];
+					scope = undefined;
 				}
 			}
 
@@ -1868,7 +2012,9 @@ module.exports.eatUntil = eatUntil;
 module.exports.eatWhiteLine = eatWhiteLine;
 module.exports.eatWhitespace = eatWhitespace;
 module.exports.eatWhitespaceAndComments = eatWhitespaceAndComments;
+module.exports.escapeIdentifier = escapeIdentifier;
 module.exports.isIdentStartCodePoint = isIdentStartCodePoint;
 module.exports.isWhiteSpace = _isWhiteSpace;
 module.exports.skipCommentsAndEatIdentSequence =
 	skipCommentsAndEatIdentSequence;
+module.exports.unescapeIdentifier = unescapeIdentifier;

package/lib/dependencies/AMDRequireDependenciesBlockParserPlugin.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
 const AMDRequireContextDependency = require("./AMDRequireContextDependency");
 const AMDRequireDependenciesBlock = require("./AMDRequireDependenciesBlock");

package/lib/dependencies/CommonJsDependencyHelpers.js

@@ -6,11 +6,72 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { propertyAccess } = require("../util/property");
 
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {"exports" | "module.exports" | "this" | "Object.defineProperty(exports)" | "Object.defineProperty(module.exports)" | "Object.defineProperty(this)"} CommonJSDependencyBaseKeywords */
 
+/**
+ * The well-known name of the ESM named export that, when present, is unwrapped
+ * by CommonJS `require()` to match Node.js v23+ `require(esm)` semantics:
+ * https://nodejs.org/docs/latest/api/modules.html#loading-ecmascript-modules-using-require
+ */
+const ESM_MODULE_EXPORTS_NAME = "module.exports";
+
+/**
+ * Whether `require()` of `importedModule` would trigger Node.js's
+ * `require(esm)` `"module.exports"` named-export unwrap. This is the
+ * usage-independent eligibility check: it only looks at module type and
+ * whether the export is declared, so it can be safely used from
+ * `getReferencedExports` before usage info is finalized (otherwise the
+ * check would be circular — we'd need `"module.exports"` to already be
+ * marked used in order to ask whether to mark it used).
+ * @param {Module} importedModule the imported module
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @returns {boolean} true if `require()` should unwrap `"module.exports"`
+ */
+const isRequireEsmModuleExportsModule = (importedModule, moduleGraph) => {
+	if (importedModule.getExportsType(moduleGraph, false) !== "namespace") {
+		return false;
+	}
+	const exportsInfo = moduleGraph.getExportsInfo(importedModule);
+	const exportInfo = exportsInfo.getReadOnlyExportInfo(ESM_MODULE_EXPORTS_NAME);
+	return exportInfo.provided === true;
+};
+
+/**
+ * When CommonJS `require()` resolves to an ES module that has a named export
+ * with the literal string name `"module.exports"`, Node.js returns the value of
+ * that export instead of the namespace object. Returns the property-access
+ * expression to apply to the require result for that unwrapping, or `null` if
+ * the imported module is not eligible (not strictly ESM, or no such export,
+ * or the export was tree-shaken away).
+ * @param {Module} importedModule the imported module
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+ * @returns {string | null} property-access expression (e.g. `["module.exports"]`), or `null`
+ */
+const getRequireEsmModuleExportsAccess = (
+	importedModule,
+	moduleGraph,
+	runtime
+) => {
+	if (!isRequireEsmModuleExportsModule(importedModule, moduleGraph)) {
+		return null;
+	}
+	const exportsInfo = moduleGraph.getExportsInfo(importedModule);
+	const usedName = exportsInfo.getUsedName([ESM_MODULE_EXPORTS_NAME], runtime);
+	if (usedName === false) return null;
+	return propertyAccess(/** @type {readonly string[]} */ (usedName));
+};
+
+module.exports.ESM_MODULE_EXPORTS_NAME = ESM_MODULE_EXPORTS_NAME;
+module.exports.getRequireEsmModuleExportsAccess =
+	getRequireEsmModuleExportsAccess;
+
 /**
  * Returns type and base.
  * @param {CommonJSDependencyBaseKeywords} depBase commonjs dependency base
@@ -64,3 +125,5 @@ module.exports.handleDependencyBase = (
 
 	return [type, base];
 };
+module.exports.isRequireEsmModuleExportsModule =
+	isRequireEsmModuleExportsModule;

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -11,7 +11,12 @@ const Template = require("../Template");
 const { equals } = require("../util/ArrayHelpers");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
-const { handleDependencyBase } = require("./CommonJsDependencyHelpers");
+const {
+	ESM_MODULE_EXPORTS_NAME,
+	getRequireEsmModuleExportsAccess,
+	handleDependencyBase,
+	isRequireEsmModuleExportsModule
+} = require("./CommonJsDependencyHelpers");
 const ModuleDependency = require("./ModuleDependency");
 const processExportInfo = require("./processExportInfo");
 
@@ -107,6 +112,16 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		const ids = this.getIds(moduleGraph);
+		const importedModule = moduleGraph.getModule(this);
+		if (
+			importedModule &&
+			isRequireEsmModuleExportsModule(importedModule, moduleGraph)
+		) {
+			// `require(esm)` unwraps the "module.exports" named export; any
+			// further property access lands on that value (which webpack does
+			// not model), so only the "module.exports" export is observable.
+			return [[ESM_MODULE_EXPORTS_NAME]];
+		}
 		const getFullResult = () => {
 			if (ids.length === 0) {
 				return Dependency.EXPORTS_OBJECT_REFERENCED;
@@ -159,17 +174,26 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 	 * @returns {ExportsSpec | undefined} export names
 	 */
 	getExports(moduleGraph) {
+		const importedModule = moduleGraph.getModule(this);
+		const esmUnwrap =
+			importedModule &&
+			isRequireEsmModuleExportsModule(importedModule, moduleGraph);
 		if (this.names.length === 1) {
 			const ids = this.getIds(moduleGraph);
 			const name = this.names[0];
 			const from = moduleGraph.getConnection(this);
 			if (!from) return;
+			const exportChain = esmUnwrap
+				? [ESM_MODULE_EXPORTS_NAME, ...ids]
+				: ids.length === 0
+					? null
+					: ids;
 			return {
 				exports: [
 					{
 						name,
 						from,
-						export: ids.length === 0 ? null : ids,
+						export: exportChain,
 						// we can't mangle names that are in an empty object
 						// because one could access the prototype property
 						// when export isn't set yet
@@ -195,6 +219,17 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		}
 		const from = moduleGraph.getConnection(this);
 		if (!from) return;
+		if (esmUnwrap) {
+			// Full re-export `module.exports = require("./esm")` of a module
+			// with a `"module.exports"` named export: the wrapping module's
+			// `module.exports` becomes the unwrapped value, whose own
+			// properties webpack cannot enumerate statically.
+			return {
+				exports: true,
+				canMangle: false,
+				dependencies: [from.module]
+			};
+		}
 		const reexportInfo = this.getStarReexports(
 			moduleGraph,
 			undefined,
@@ -393,14 +428,23 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 		});
 		if (importedModule) {
 			const ids = dep.getIds(moduleGraph);
-			const usedImported = moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(ids, runtime);
-			if (usedImported) {
-				const comment = equals(usedImported, ids)
-					? ""
-					: `${Template.toNormalComment(propertyAccess(ids))} `;
-				requireExpr += `${comment}${propertyAccess(usedImported)}`;
+			const esmRequireAccess = getRequireEsmModuleExportsAccess(
+				importedModule,
+				moduleGraph,
+				runtime
+			);
+			if (esmRequireAccess !== null) {
+				requireExpr += `${esmRequireAccess}${propertyAccess(ids)}`;
+			} else {
+				const usedImported = moduleGraph
+					.getExportsInfo(importedModule)
+					.getUsedName(ids, runtime);
+				if (usedImported) {
+					const comment = equals(usedImported, ids)
+						? ""
+						: `${Template.toNormalComment(propertyAccess(ids))} `;
+					requireExpr += `${comment}${propertyAccess(usedImported)}`;
+				}
 			}
 		}
 

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -6,8 +6,8 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const formatLocation = require("../formatLocation");
 const { evaluateToString } = require("../javascript/JavascriptParserHelpers");
+const formatLocation = require("../util/formatLocation");
 const { propertyAccess } = require("../util/property");
 const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
 const CommonJsExportsDependency = require("./CommonJsExportsDependency");

package/lib/dependencies/CommonJsFullRequireDependency.js

@@ -10,6 +10,11 @@ const { equals } = require("../util/ArrayHelpers");
 const { getTrimmedIdsAndRange } = require("../util/chainedImports");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
+const {
+	ESM_MODULE_EXPORTS_NAME,
+	getRequireEsmModuleExportsAccess,
+	isRequireEsmModuleExportsModule
+} = require("./CommonJsDependencyHelpers");
 const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
@@ -55,14 +60,22 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		if (this.call) {
-			const importedModule = moduleGraph.getModule(this);
-			if (
-				!importedModule ||
-				importedModule.getExportsType(moduleGraph, false) !== "namespace"
-			) {
-				return [this.names.slice(0, -1)];
-			}
+		const importedModule = moduleGraph.getModule(this);
+		if (
+			importedModule &&
+			isRequireEsmModuleExportsModule(importedModule, moduleGraph)
+		) {
+			// When `require(esm)` unwraps a `"module.exports"` named export, the
+			// user's property access lands on that value (which webpack does not
+			// model), so only the "module.exports" export itself is referenced.
+			return [[ESM_MODULE_EXPORTS_NAME]];
+		}
+		if (
+			this.call &&
+			(!importedModule ||
+				importedModule.getExportsType(moduleGraph, false) !== "namespace")
+		) {
+			return [this.names.slice(0, -1)];
 		}
 		return [this.names];
 	}
@@ -128,6 +141,10 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 			runtimeRequirements
 		});
 
+		const esmRequireAccess = importedModule
+			? getRequireEsmModuleExportsAccess(importedModule, moduleGraph, runtime)
+			: null;
+
 		const {
 			trimmedRange: [trimmedRangeStart, trimmedRangeEnd],
 			trimmedIds
@@ -139,7 +156,13 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 			dep
 		);
 
-		if (importedModule) {
+		if (esmRequireAccess !== null) {
+			const access = `${esmRequireAccess}${propertyAccess(trimmedIds)}`;
+			requireExpr =
+				dep.asiSafe === true
+					? `(${requireExpr}${access})`
+					: `${requireExpr}${access}`;
+		} else if (importedModule) {
 			const usedImported = moduleGraph
 				.getExportsInfo(importedModule)
 				.getUsedName(trimmedIds, runtime);

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const CommentCompilationWarning = require("../CommentCompilationWarning");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
+const CommentCompilationWarning = require("../errors/CommentCompilationWarning");
+const UnsupportedFeatureWarning = require("../errors/UnsupportedFeatureWarning");
 const {
 	evaluateToIdentifier,
 	evaluateToString,
@@ -160,7 +160,8 @@ const createRequireCallHandler = (parser, options, getContext) => {
 				/** @type {string} */ (param.string),
 				/** @type {Range} */ (param.range),
 				getContext(),
-				referencedExports
+				referencedExports,
+				/** @type {Range} */ (expr.range)
 			);
 			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			dep.optional = Boolean(parser.scope.inTry);

package/lib/dependencies/CommonJsRequireDependency.js

@@ -7,11 +7,18 @@
 
 const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
+const {
+	ESM_MODULE_EXPORTS_NAME,
+	getRequireEsmModuleExportsAccess,
+	isRequireEsmModuleExportsModule
+} = require("./CommonJsDependencyHelpers");
 const ModuleDependency = require("./ModuleDependency");
-const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
 
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @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("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -22,15 +29,23 @@ class CommonJsRequireDependency extends ModuleDependency {
 	/**
 	 * Creates an instance of CommonJsRequireDependency.
 	 * @param {string} request request
-	 * @param {Range=} range location in source code
+	 * @param {Range=} range location in source code of the string-literal argument (gets replaced by the module id)
 	 * @param {string=} context request context
 	 * @param {RawReferencedExports | null=} referencedExports list of referenced exports
+	 * @param {Range=} valueRange location in source code of the whole `require(...)` call (for `require(esm)` interop)
 	 */
-	constructor(request, range, context, referencedExports = null) {
+	constructor(
+		request,
+		range,
+		context,
+		referencedExports = null,
+		valueRange = undefined
+	) {
 		super(request);
 		this.range = range;
 		this._context = context;
 		this.referencedExports = referencedExports;
+		this.valueRange = valueRange;
 	}
 
 	get type() {
@@ -48,6 +63,15 @@ class CommonJsRequireDependency extends ModuleDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
+		const importedModule = moduleGraph.getModule(this);
+		if (
+			importedModule &&
+			isRequireEsmModuleExportsModule(importedModule, moduleGraph)
+		) {
+			// `require(esm)` will unwrap the "module.exports" named export; only
+			// that export is observable through this `require()` call.
+			return [[ESM_MODULE_EXPORTS_NAME]];
+		}
 		if (!this.referencedExports) return Dependency.EXPORTS_OBJECT_REFERENCED;
 		return this.referencedExports.map((name) => ({
 			name,
@@ -62,6 +86,7 @@ class CommonJsRequireDependency extends ModuleDependency {
 	serialize(context) {
 		const { write } = context;
 		write(this.referencedExports);
+		write(this.valueRange);
 		super.serialize(context);
 	}
 
@@ -72,11 +97,49 @@ class CommonJsRequireDependency extends ModuleDependency {
 	deserialize(context) {
 		const { read } = context;
 		this.referencedExports = read();
+		this.valueRange = read();
 		super.deserialize(context);
 	}
 }
 
-CommonJsRequireDependency.Template = ModuleDependencyTemplateAsId;
+CommonJsRequireDependency.Template = class CommonJsRequireDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(
+		dependency,
+		source,
+		{ runtimeTemplate, moduleGraph, chunkGraph, runtime }
+	) {
+		const dep = /** @type {CommonJsRequireDependency} */ (dependency);
+		if (!dep.range) return;
+		const importedModule = /** @type {Module} */ (moduleGraph.getModule(dep));
+		const content = runtimeTemplate.moduleId({
+			module: importedModule,
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak
+		});
+		source.replace(dep.range[0], dep.range[1] - 1, content);
+
+		if (dep.valueRange && importedModule) {
+			const access = getRequireEsmModuleExportsAccess(
+				importedModule,
+				moduleGraph,
+				runtime
+			);
+			if (access !== null) {
+				source.insert(dep.valueRange[1], access);
+			}
+		}
+	}
+};
 
 makeSerializable(
 	CommonJsRequireDependency,

package/lib/dependencies/ContextDependency.js

@@ -14,7 +14,7 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../ContextModule").ContextOptions} ContextOptions */
 /** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 

package/lib/dependencies/ContextDependencyHelpers.js

@@ -48,7 +48,7 @@ const splitContextFromPrefix = (prefix) => {
 /**
  * Defines the get additional dep args type used by this module.
  * @template T
- * @typedef {T extends new (options: ContextDependencyOptions, range: Range, valueRange: Range, ...remains: infer R) => EXPECTED_ANY ? R : []} GetAdditionalDepArgs
+ * @typedef {T extends new (options: ContextDependencyOptions, range: Range, valueRange: Range, ...remains: infer R) => ContextDependency ? R : []} GetAdditionalDepArgs
  */
 
 /**

package/lib/dependencies/CreateRequireParserPlugin.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const { fileURLToPath } = require("url");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { VariableInfo } = require("../javascript/JavascriptParser");
 const {

package/lib/dependencies/CriticalDependencyWarning.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const makeSerializable = require("../util/makeSerializable");
 
 class CriticalDependencyWarning extends WebpackError {