webpack 5.107.2 → 5.108.0

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -19,7 +19,9 @@ const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
 /** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").Super} Super */
+/** @typedef {import("estree").ThisExpression} ThisExpression */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
@@ -29,7 +31,7 @@ const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
 /** @typedef {import("../javascript/JavascriptParser").Members} Members */
 /** @typedef {import("../javascript/JavascriptParser").StatementPath} StatementPath */
 /** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
 
 /**
  * This function takes a generic expression and detects whether it is an ObjectExpression.
@@ -59,6 +61,55 @@ const getValueOfPropertyDescription = (expr) => {
 	}
 };
 
+/**
+ * Extracts the re-exportable expression from a property descriptor, handling
+ * both the eager `{ value: <expr> }` form and the lazy
+ * `{ get: () => <expr> }` / `{ get() { return <expr>; } }` accessor form used
+ * by barrel files (e.g. webpack's own `lib/index.js`). A `set` accessor cannot
+ * be reproduced by the rewritten descriptor, so descriptors with a setter are
+ * left to the generic handler (which keeps the descriptor verbatim).
+ * @param {Expression} expr property descriptor expression
+ * @returns {{ expr: Expression, getter: boolean } | undefined} the value expression and whether it is a lazy getter
+ */
+const getReexportOfPropertyDescriptor = (expr) => {
+	if (expr.type !== "ObjectExpression") return;
+	/** @type {Expression | undefined} */
+	let valueExpr;
+	/** @type {Expression | undefined} */
+	let getFn;
+	for (const property of expr.properties) {
+		if (property.type === "SpreadElement" || property.computed) continue;
+		const key = property.key;
+		if (key.type !== "Identifier") continue;
+		// A setter would be silently dropped by the rewrite — bail out.
+		if (key.name === "set") return;
+		if (key.name === "value") {
+			valueExpr = /** @type {Expression} */ (property.value);
+		} else if (key.name === "get") {
+			getFn = /** @type {Expression} */ (property.value);
+		}
+	}
+	if (valueExpr) return { expr: valueExpr, getter: false };
+	if (
+		getFn &&
+		(getFn.type === "FunctionExpression" ||
+			getFn.type === "ArrowFunctionExpression")
+	) {
+		// Arrow with expression body: `() => require("./x")`.
+		if (getFn.body.type !== "BlockStatement") {
+			return { expr: /** @type {Expression} */ (getFn.body), getter: true };
+		}
+		// Function body must be exactly `return <expr>;`.
+		if (
+			getFn.body.body.length === 1 &&
+			getFn.body.body[0].type === "ReturnStatement" &&
+			getFn.body.body[0].argument
+		) {
+			return { expr: getFn.body.body[0].argument, getter: true };
+		}
+	}
+};
+
 /**
  * The purpose of this function is to check whether an expression is a truthy literal or not. This is
  * useful when parsing CommonJS exports, because CommonJS modules can export any value, including falsy
@@ -129,6 +180,105 @@ const parseRequireCall = (parser, expr) => {
 	return { argument: argValue, ids: ids.reverse() };
 };
 
+/**
+ * Checks if a value is an AST node.
+ * @param {unknown} value candidate
+ * @returns {value is Node} true when the value is an AST node
+ */
+const isNode = (value) =>
+	typeof value === "object" &&
+	value !== null &&
+	typeof (/** @type {{ type?: unknown }} */ (value).type) === "string";
+
+/** Positional/metadata keys that never hold child AST nodes. */
+const NON_CHILD_KEYS = new Set([
+	"type",
+	"start",
+	"end",
+	"loc",
+	"range",
+	"leadingComments",
+	"trailingComments"
+]);
+
+/** @type {Map<string, string[]>} per node type: own keys that may hold child nodes */
+const childKeysByType = new Map();
+
+/**
+ * Returns the keys of a node that may hold child nodes, excluding positional
+ * metadata. Computed once per node type and cached: acorn initializes every
+ * field of a given type (to `null` when absent), so the key set is stable, and
+ * the cache stays allocation-free on the hot path after the first node of each
+ * type is seen.
+ * @param {Node} node node
+ * @returns {string[]} candidate child keys
+ */
+const getChildKeys = (node) => {
+	let keys = childKeysByType.get(node.type);
+	if (keys === undefined) {
+		keys = Object.keys(node).filter((key) => !NON_CHILD_KEYS.has(key));
+		childKeysByType.set(node.type, keys);
+	}
+	return keys;
+};
+
+/**
+ * Searches for a `this` belonging to the scanned function's own `this`-scope.
+ * Descends into arrow functions, but not into nested functions, static blocks
+ * and class field values, which have their own `this`. Class method bodies are
+ * function expressions and are skipped by the same rule, while computed keys
+ * and `extends` clauses evaluate in the outer scope and are searched. The
+ * `this`-scope boundary is enforced when a node is popped, so the generic
+ * branch may enumerate any child without crossing it.
+ * @param {Node[]} initialNodes nodes to search
+ * @returns {ThisExpression | undefined} first own `this` expression
+ */
+const findOwnThisExpression = (initialNodes) => {
+	const stack = [...initialNodes];
+	let node;
+	while ((node = stack.pop()) !== undefined) {
+		switch (node.type) {
+			case "ThisExpression":
+				return node;
+			case "FunctionExpression":
+			case "FunctionDeclaration":
+			case "StaticBlock":
+				break;
+			case "PropertyDefinition":
+				if (node.computed) stack.push(node.key);
+				break;
+			default: {
+				const children =
+					/** @type {Record<string, unknown>} */
+					(/** @type {unknown} */ (node));
+				const keys = getChildKeys(node);
+				for (let i = 0; i < keys.length; i++) {
+					const value = children[keys[i]];
+					if (Array.isArray(value)) {
+						for (const item of value) {
+							if (isNode(item)) stack.push(item);
+						}
+					} else if (isNode(value)) {
+						stack.push(value);
+					}
+				}
+			}
+		}
+	}
+};
+
+/**
+ * Returns the own `this` of a function-expression export value. When such a
+ * function is called as a method of the exports object, `this` is the exports
+ * object and may reach any sibling export (#21178).
+ * @param {Node} expr the exported value
+ * @returns {ThisExpression | undefined} first own `this` expression
+ */
+const getThisAccessInExportedValue = (expr) =>
+	expr.type === "FunctionExpression"
+		? findOwnThisExpression([...expr.params, expr.body])
+		: undefined;
+
 const PLUGIN_NAME = "CommonJsExportsParserPlugin";
 
 class CommonJsExportsParserPlugin {
@@ -137,6 +287,7 @@ class CommonJsExportsParserPlugin {
 	 * @param {ModuleGraph} moduleGraph module graph
 	 */
 	constructor(moduleGraph) {
+		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
 	}
 
@@ -184,6 +335,36 @@ class CommonJsExportsParserPlugin {
 				.getOptimizationBailout(parser.state.module)
 				.push(`CommonJS bailout: ${reason}`);
 		};
+		/** @type {unknown} */
+		let keptAllExportsForState;
+		/**
+		 * An exported function accessing its own `this` may reach any export
+		 * through it when called as a method of the exports object, so the
+		 * whole exports object must be kept (#21178).
+		 * @param {Node} valueExpr the exported value
+		 * @param {CommonJSDependencyBaseKeywords} base commonjs base keywords
+		 * @returns {void}
+		 */
+		const keepAllExportsOnThisAccess = (valueExpr, base) => {
+			// One bailout per module is enough
+			if (keptAllExportsForState === parser.state) return;
+			const thisExpr = getThisAccessInExportedValue(valueExpr);
+			if (thisExpr === undefined) return;
+			keptAllExportsForState = parser.state;
+			bailoutHint(
+				`this in exported function may access any export, so all exports are kept, at ${formatLocation(
+					/** @type {DependencyLocation} */ (thisExpr.loc)
+				)}`
+			);
+			const dep = new CommonJsSelfReferenceDependency(
+				/** @type {Range} */ (thisExpr.range),
+				base,
+				[],
+				false
+			);
+			dep.loc = /** @type {DependencyLocation} */ (thisExpr.loc);
+			parser.state.module.addDependency(dep);
+		};
 
 		// metadata //
 		parser.hooks.evaluateTypeof
@@ -226,7 +407,7 @@ class CommonJsExportsParserPlugin {
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.module.addDependency(dep);
-				/** @type {BuildMeta} */ (
+				/** @type {JavascriptModuleBuildMeta} */ (
 					parser.state.module.buildMeta
 				).treatAsCommonJs = true;
 
@@ -250,8 +431,10 @@ class CommonJsExportsParserPlugin {
 			);
 			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			parser.state.module.addDependency(dep);
-			/** @type {BuildMeta} */ (parser.state.module.buildMeta).treatAsCommonJs =
-				true;
+			/** @type {JavascriptModuleBuildMeta} */ (
+				parser.state.module.buildMeta
+			).treatAsCommonJs = true;
+			keepAllExportsOnThisAccess(expr.right, base);
 			parser.walkExpression(expr.right);
 			return true;
 		};
@@ -295,6 +478,33 @@ class CommonJsExportsParserPlugin {
 				if (typeof property !== "string") return;
 				enableStructuredExports();
 				const descArg = expr.arguments[2];
+				// Handle reexporting: `Object.defineProperty(exports, "x", { value: require("./y")[.z] })`
+				// and the lazy getter form `{ get: () => require("./y")[.z] }`.
+				if (property !== "__esModule") {
+					const reexport = getReexportOfPropertyDescriptor(descArg);
+					const requireCall =
+						reexport && parseRequireCall(parser, reexport.expr);
+					if (reexport && requireCall && requireCall.argument.isString()) {
+						const dep = new CommonJsExportRequireDependency(
+							/** @type {Range} */ (expr.range),
+							/** @type {Range} */ (reexport.expr.range),
+							`Object.defineProperty(${exportsArg.identifier})`,
+							[property],
+							/** @type {string} */ (requireCall.argument.string),
+							requireCall.ids,
+							false
+						);
+						dep.getter = reexport.getter;
+						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+						dep.optional = Boolean(parser.scope.inTry);
+						parser.state.module.addDependency(dep);
+						/** @type {JavascriptModuleBuildMeta} */ (
+							parser.state.module.buildMeta
+						).treatAsCommonJs = true;
+
+						return true;
+					}
+				}
 				checkNamespace(
 					/** @type {StatementPath} */
 					(parser.statementPath).length === 1,
@@ -309,10 +519,22 @@ class CommonJsExportsParserPlugin {
 				);
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.module.addDependency(dep);
-				/** @type {BuildMeta} */ (
+				/** @type {JavascriptModuleBuildMeta} */ (
 					parser.state.module.buildMeta
 				).treatAsCommonJs = true;
 
+				if (descArg.type === "ObjectExpression") {
+					// `value`, `get` and `set` descriptor functions are all called
+					// with the exports object as `this`
+					for (const descProperty of descArg.properties) {
+						if (descProperty.type === "SpreadElement") continue;
+						keepAllExportsOnThisAccess(
+							descProperty.value,
+							/** @type {CommonJSDependencyBaseKeywords} */
+							(exportsArg.identifier)
+						);
+					}
+				}
 				parser.walkExpression(expr.arguments[2]);
 				return true;
 			});
@@ -353,8 +575,9 @@ class CommonJsExportsParserPlugin {
 			);
 			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			parser.state.module.addDependency(dep);
-			/** @type {BuildMeta} */ (parser.state.module.buildMeta).treatAsCommonJs =
-				true;
+			/** @type {JavascriptModuleBuildMeta} */ (
+				parser.state.module.buildMeta
+			).treatAsCommonJs = true;
 
 			if (call) {
 				parser.walkExpressions(call.arguments);

package/lib/dependencies/CommonJsFullRequireDependency.js

@@ -24,10 +24,10 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean]>} ObjectSerializerContext */
 
 class CommonJsFullRequireDependency extends ModuleDependency {
 	/**
@@ -45,7 +45,9 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	) {
 		super(request);
 		this.range = range;
+		/** @type {string[]} */
 		this.names = names;
+		/** @type {IdRanges | undefined} */
 		this.idRanges = idRanges;
 		/** @type {boolean} */
 		this.call = false;
@@ -61,6 +63,7 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	 */
 	getReferencedExports(moduleGraph, runtime) {
 		const importedModule = moduleGraph.getModule(this);
+		// CommonJS property access is never rewritten to a literal, so it can't inline
 		if (
 			importedModule &&
 			isRequireEsmModuleExportsModule(importedModule, moduleGraph)
@@ -68,16 +71,16 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 			// 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]];
+			return [{ name: [ESM_MODULE_EXPORTS_NAME], canInline: false }];
 		}
 		if (
 			this.call &&
 			(!importedModule ||
 				importedModule.getExportsType(moduleGraph, false) !== "namespace")
 		) {
-			return [this.names.slice(0, -1)];
+			return [{ name: this.names.slice(0, -1), canInline: false }];
 		}
-		return [this.names];
+		return [{ name: this.names, canInline: false }];
 	}
 
 	/**
@@ -85,11 +88,11 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-		write(this.names);
-		write(this.idRanges);
-		write(this.call);
-		write(this.asiSafe);
+		context
+			.write(this.names)
+			.write(this.idRanges)
+			.write(this.call)
+			.write(this.asiSafe);
 		super.serialize(context);
 	}
 
@@ -98,12 +101,14 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-		this.names = read();
-		this.idRanges = read();
-		this.call = read();
-		this.asiSafe = read();
-		super.deserialize(context);
+		this.names = context.read();
+		const c1 = context.rest;
+		this.idRanges = c1.read();
+		const c2 = c1.rest;
+		this.call = c2.read();
+		const c3 = c2.rest;
+		this.asiSafe = c3.read();
+		super.deserialize(c3.rest);
 	}
 
 	get type() {
@@ -163,9 +168,12 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 					? `(${requireExpr}${access})`
 					: `${requireExpr}${access}`;
 		} else if (importedModule) {
-			const usedImported = moduleGraph
-				.getExportsInfo(importedModule)
-				.getUsedName(trimmedIds, runtime);
+			// CJS exports are never inlined
+			const usedImported = /** @type {string | string[] | false} */ (
+				moduleGraph
+					.getExportsInfo(importedModule)
+					.getUsedName(trimmedIds, runtime)
+			);
 			if (usedImported) {
 				const comment = equals(usedImported, trimmedIds)
 					? ""

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -14,6 +14,7 @@ const {
 	expressionIsUnsupported,
 	toConstantDependency
 } = require("../javascript/JavascriptParserHelpers");
+const memoize = require("../util/memoize");
 const traverseDestructuringAssignmentProperties = require("../util/traverseDestructuringAssignmentProperties");
 const CommonJsFullRequireDependency = require("./CommonJsFullRequireDependency");
 const CommonJsRequireContextDependency = require("./CommonJsRequireContextDependency");
@@ -53,12 +54,11 @@ const RequireResolveHeaderDependency = require("./RequireResolveHeaderDependency
  * member-access references on `NAME` to the `CommonJsRequireDependency`
  * created for the `require()` call.
  * @typedef {object} RequireBindingData
- * @property {RawReferencedExports} referencedExports mutable list shared with the dependency; pushed to as `NAME.x.y` accesses are walked
- * @property {InstanceType<typeof import("./CommonJsRequireDependency")> | null} dep dependency for the `require()` call (assigned during walk)
+ * @property {RawReferencedExports | null} referencedExports mutable list, pushed to as `NAME.x.y` accesses are walked; null means the whole namespace is used. Separate from `dep` so a deferred require (walked after accesses on `NAME`) still collects them; becomes the dep's shared list on creation.
+ * @property {InstanceType<typeof import("./CommonJsRequireDependency")> | null} dep dependency for the `require()` call, null until the `require()` is walked; kept so a later whole-namespace use can null its list directly
  */
 
-/** @type {WeakMap<CallExpression, RequireBindingData>} */
-const requireBindingData = new WeakMap();
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
 
 const REQUIRE_BINDING_TAG = Symbol(
 	"CommonJsImportsParserPlugin require binding"
@@ -157,9 +157,15 @@ const createRequireAsExpressionHandler =
  * @param {JavascriptParser} parser parser
  * @param {JavascriptParserOptions} options options
  * @param {() => undefined | string} getContext context accessor
+ * @param {WeakMap<CallExpression, RequireBindingData>=} requireBindingData per-parser `const NAME = require(LITERAL)` binding state; only the free-`require` plugin populates it
  * @returns {(callNew: boolean) => (expr: CallExpression | NewExpression) => (boolean | void)} handler factory
  */
-const createRequireCallHandler = (parser, options, getContext) => {
+const createRequireCallHandler = (
+	parser,
+	options,
+	getContext,
+	requireBindingData
+) => {
 	/**
 	 * Process require item.
 	 * @param {CallExpression | NewExpression} expr expression
@@ -172,9 +178,9 @@ const createRequireCallHandler = (parser, options, getContext) => {
 				parser,
 				expr
 			);
-			const binding = requireBindingData.get(
-				/** @type {CallExpression} */ (expr)
-			);
+			const binding =
+				requireBindingData &&
+				requireBindingData.get(/** @type {CallExpression} */ (expr));
 			if (binding && !referencedExports) {
 				// `const NAME = require(LITERAL)` — let later member-access walks
 				// on `NAME` populate the dependency's referenced exports.
@@ -191,6 +197,7 @@ const createRequireCallHandler = (parser, options, getContext) => {
 			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 			dep.optional = Boolean(parser.scope.inTry);
 			parser.state.current.addDependency(dep);
+			getHarmonyImportGuard().attachDependencyGuards(parser, dep);
 			return true;
 		}
 	};
@@ -436,6 +443,7 @@ class CommonJsImportsParserPlugin {
 	 * @param {JavascriptParserOptions} options parser options
 	 */
 	constructor(options) {
+		/** @type {JavascriptParserOptions} */
 		this.options = options;
 	}
 
@@ -577,10 +585,13 @@ class CommonJsImportsParserPlugin {
 		 * @param {boolean} callNew true, when require is called with new
 		 * @returns {(expr: CallExpression | NewExpression) => (boolean | void)} handler
 		 */
+		/** @type {WeakMap<CallExpression, RequireBindingData>} */
+		const requireBindingData = new WeakMap();
 		const createRequireHandler = createRequireCallHandler(
 			parser,
 			options,
-			getContext
+			getContext,
+			requireBindingData
 		);
 		parser.hooks.call
 			.for("require")
@@ -727,11 +738,15 @@ class CommonJsImportsParserPlugin {
 			const binding =
 				/** @type {RequireBindingData} */
 				(parser.currentTagData);
-			if (binding && binding.dep) {
+			if (binding) {
 				// `NAME` is read as a value (not as the object of a static member
 				// chain), so we have to assume the whole exports object is used.
-				binding.dep.referencedExports = null;
+				binding.referencedExports = null;
+				if (binding.dep) {
+					binding.dep.referencedExports = null;
+				}
 			}
+			return true;
 		});
 
 		parser.hooks.expressionMemberChain
@@ -740,8 +755,8 @@ class CommonJsImportsParserPlugin {
 				const binding =
 					/** @type {RequireBindingData} */
 					(parser.currentTagData);
-				if (binding && binding.dep && binding.dep.referencedExports) {
-					binding.dep.referencedExports.push(members);
+				if (binding && binding.referencedExports) {
+					binding.referencedExports.push(members);
 				}
 				// Returning truthy suppresses the parser's fallback chain (which
 				// would otherwise walk `NAME` as a bare expression and trigger our
@@ -755,18 +770,38 @@ class CommonJsImportsParserPlugin {
 				const binding =
 					/** @type {RequireBindingData} */
 					(parser.currentTagData);
-				if (binding && binding.dep && binding.dep.referencedExports) {
+				if (binding && binding.referencedExports) {
 					if (members.length === 0) {
 						// `NAME(...)` — calling the require result directly; the
 						// whole exports object is observable.
-						binding.dep.referencedExports = null;
+						binding.referencedExports = null;
+						if (binding.dep) {
+							binding.dep.referencedExports = null;
+						}
 					} else {
-						binding.dep.referencedExports.push(members);
+						binding.referencedExports.push(members);
 					}
 				}
 				if (expr.arguments) parser.walkExpressions(expr.arguments);
 				return true;
 			});
+
+		// Re-exporting the binding lets the require result escape, so the whole
+		// exports object is observable. Stage -10 runs before the harmony bail tap.
+		parser.hooks.exportSpecifier.tap(
+			{ name: PLUGIN_NAME, stage: -10 },
+			(_statement, id) => {
+				const binding =
+					/** @type {RequireBindingData | undefined} */
+					(parser.getTagData(id, REQUIRE_BINDING_TAG));
+				if (binding) {
+					binding.referencedExports = null;
+					if (binding.dep) {
+						binding.dep.referencedExports = null;
+					}
+				}
+			}
+		);
 		// #endregion
 
 		// #region Require.resolve

package/lib/dependencies/CommonJsPlugin.js

@@ -281,7 +281,7 @@ class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
 				"Object.defineProperty(module, 'exports', {",
 				Template.indent([
 					"enumerable: true,",
-					`set: ${runtimeTemplate.basicFunction("", [
+					`${runtimeTemplate.method("set", "", [
 						"throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);"
 					])}`
 				]),

package/lib/dependencies/CommonJsRequireContextDependency.js

@@ -11,8 +11,8 @@ const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
 
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range, Range | undefined, boolean | string | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range, Range | undefined, boolean | string | undefined]>} ObjectSerializerContext */
 /** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 /** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
@@ -34,6 +34,7 @@ class CommonJsRequireContextDependency extends ContextDependency {
 		this.range = range;
 		this.valueRange = valueRange;
 		// inShorthand must be serialized by subclasses that use it
+		/** @type {string | boolean | undefined} */
 		this.inShorthand = inShorthand;
 	}
 
@@ -62,11 +63,7 @@ class CommonJsRequireContextDependency extends ContextDependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
-		const { write } = context;
-
-		write(this.range);
-		write(this.valueRange);
-		write(this.inShorthand);
+		context.write(this.range).write(this.valueRange).write(this.inShorthand);
 
 		super.serialize(context);
 	}
@@ -76,13 +73,13 @@ class CommonJsRequireContextDependency extends ContextDependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
-		const { read } = context;
-
-		this.range = read();
-		this.valueRange = read();
-		this.inShorthand = read();
+		this.range = context.read();
+		const c1 = context.rest;
+		this.valueRange = c1.read();
+		const c2 = c1.rest;
+		this.inShorthand = c2.read();
 
-		super.deserialize(context);
+		super.deserialize(c2.rest);
 	}
 }