webpack 5.111.1 → 5.112.1

package/lib/dependencies/{CommonJsExportsParserPlugin.js → commonjs/CommonJsExportsParserPlugin.js}

@@ -5,21 +5,28 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const { evaluateToString } = require("../javascript/JavascriptParserHelpers");
-const { recordOptimizationBailout } = require("../util/buildDiagnostics");
-const formatLocation = require("../util/formatLocation");
-const { propertyAccess } = require("../util/property");
+const isDependencyKind = require("../../graph/isDependencyKind");
+const {
+	evaluateToString
+} = require("../../javascript/JavascriptParserHelpers");
+const RuntimeGlobals = require("../../runtime/RuntimeGlobals");
+const { recordOptimizationBailout } = require("../../util/buildDiagnostics");
+const formatLocation = require("../../util/formatLocation");
+const memoize = require("../../util/memoize");
+const { propertyAccess } = require("../../util/property");
+
+const RuntimeRequirementsDependency = require("../core/RuntimeRequirementsDependency");
+const ESMExports = require("../esm/ESMExports");
+const DynamicExports = require("../helpers/DynamicExports");
 const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
 const CommonJsExportsDependency = require("./CommonJsExportsDependency");
-const CommonJsFullRequireDependency = require("./CommonJsFullRequireDependency");
 const CommonJsObjectExportDependency = require("./CommonJsObjectExportDependency");
-const CommonJsRequireDependency = require("./CommonJsRequireDependency");
 const CommonJsSelfReferenceDependency = require("./CommonJsSelfReferenceDependency");
-const DynamicExports = require("./DynamicExports");
-const HarmonyExports = require("./HarmonyExports");
 const ModuleDecoratorDependency = require("./ModuleDecoratorDependency");
-const RuntimeRequirementsDependency = require("./RuntimeRequirementsDependency");
+
+const getRequireBindingTag = memoize(
+	() => require("./CommonJsImportsParserPlugin").REQUIRE_BINDING_TAG
+);
 
 const FUNCTION_PROPERTY_DROP_HEAD =
 	CommonJsObjectExportDependency.FUNCTION_PROPERTY_DROP_HEAD;
@@ -38,15 +45,20 @@ const FUNCTION_PROPERTY_DROP_HEAD =
  * 	ThisExpression
  * } from "estree"
  */
-/** @import { ExportInfoName } from "../Dependency" */
-/** @import { BuildInfo } from "../Module" */
-/** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../../declarations/WebpackOptions"
+ */
+/** @import CommonJsRequireDependency from "./CommonJsRequireDependency" */
+/** @import { ExportInfoName } from "../../graph/Dependency" */
+
 /**
  * @import JavascriptParser, {
  * 	Range,
  * 	Members,
  * 	StatementPath
- * } from "../javascript/JavascriptParser"
+ * } from "../../javascript/JavascriptParser"
  */
 /**
  * @import {
@@ -58,11 +70,7 @@ const FUNCTION_PROPERTY_DROP_HEAD =
  * 	CommonJsObjectExportKind
  * } from "./CommonJsObjectExportDependency"
  */
-/**
- * @import {
- * 	JavascriptModuleBuildMeta
- * } from "../javascript/JavascriptModule"
- */
+/** @import { RequireBindingData } from "./CommonJsImportsParserPlugin" */
 
 /**
  * This function takes a generic expression and detects whether it is an ObjectExpression.
@@ -92,13 +100,27 @@ const getValueOfPropertyDescription = (expr) => {
 	}
 };
 
+const DESCRIPTOR_ATTRIBUTES = new Set([
+	"enumerable",
+	"configurable",
+	"writable"
+]);
+
+/**
+ * Whether an attribute value names no binding, like `true` or a minifier's `!0`.
+ * @param {Expression} expr attribute value
+ * @returns {boolean} true, when the value is a literal, possibly under a unary operator
+ */
+const isConstantAttribute = (expr) =>
+	expr.type === "Literal" ||
+	(expr.type === "UnaryExpression" && expr.argument.type === "Literal");
+
 /**
  * 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).
+ * by barrel files (e.g. webpack's own `lib/index.js`). Any other property must
+ * be a literal attribute, since the descriptor is kept as written but not walked.
  * @param {Expression} expr property descriptor expression
  * @returns {{ expr: Expression, getter: boolean } | undefined} the value expression and whether it is a lazy getter
  */
@@ -109,15 +131,19 @@ const getReexportOfPropertyDescriptor = (expr) => {
 	/** @type {Expression | undefined} */
 	let getFn;
 	for (const property of expr.properties) {
-		if (property.type === "SpreadElement" || property.computed) continue;
+		if (property.type === "SpreadElement" || property.computed) return;
 		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.type !== "Identifier") return;
 		if (key.name === "value") {
 			valueExpr = /** @type {Expression} */ (property.value);
 		} else if (key.name === "get") {
 			getFn = /** @type {Expression} */ (property.value);
+		} else if (
+			!DESCRIPTOR_ATTRIBUTES.has(key.name) ||
+			!isConstantAttribute(/** @type {Expression} */ (property.value))
+		) {
+			// a setter, an unknown key or a computed attribute: not a plain re-export
+			return;
 		}
 	}
 	if (valueExpr) return { expr: valueExpr, getter: false };
@@ -126,9 +152,14 @@ const getReexportOfPropertyDescriptor = (expr) => {
 		(getFn.type === "FunctionExpression" ||
 			getFn.type === "ArrowFunctionExpression")
 	) {
+		// A parameter or the function's own name would shadow a `const` binding the body names.
+		if (getFn.params.length > 0) return;
+		if (getFn.type === "FunctionExpression" && getFn.id) return;
+		// An async or generator getter returns a wrapper, not the re-exported value.
+		if (getFn.async || getFn.generator) return;
 		// Arrow with expression body: `() => require("./x")`.
 		if (getFn.body.type !== "BlockStatement") {
-			return { expr: /** @type {Expression} */ (getFn.body), getter: true };
+			return { expr: getFn.body, getter: true };
 		}
 		// Function body must be exactly `return <expr>;`.
 		if (
@@ -176,10 +207,10 @@ const isFalsyLiteral = (expr) => {
 };
 
 /**
- * Parses require call.
+ * Parses a `require()` call, or a `const` binding of one, under a static member chain.
  * @param {JavascriptParser} parser the parser
  * @param {Expression} expr expression
- * @returns {{ argument: BasicEvaluatedExpression, ids: ExportInfoName[] } | undefined} parsed call
+ * @returns {{ request: string, ids: ExportInfoName[], binding?: { range: Range, dep: CommonJsRequireDependency } } | undefined} parsed call, with the binding it reads
  */
 const parseRequireCall = (parser, expr) => {
 	/** @type {ExportInfoName[]} */
@@ -197,6 +228,18 @@ const parseRequireCall = (parser, expr) => {
 		}
 		expr = expr.object;
 	}
+	if (expr.type === "Identifier") {
+		const binding =
+			/** @type {RequireBindingData | undefined} */
+			(parser.getTagData(expr.name, getRequireBindingTag()));
+		// No dependency: `webpackIgnore`, a local module, or not walked yet.
+		if (!binding || !binding.dep) return;
+		return {
+			request: binding.request,
+			ids: ids.reverse(),
+			binding: { range: /** @type {Range} */ (expr.range), dep: binding.dep }
+		};
+	}
 	if (expr.type !== "CallExpression" || expr.arguments.length !== 1) return;
 	const callee = expr.callee;
 	if (
@@ -208,18 +251,25 @@ const parseRequireCall = (parser, expr) => {
 	const arg = expr.arguments[0];
 	if (arg.type === "SpreadElement") return;
 	const argValue = parser.evaluateExpression(arg);
-	return { argument: argValue, ids: ids.reverse() };
+	if (!argValue.isString()) return;
+	return {
+		request: /** @type {string} */ (argValue.string),
+		ids: ids.reverse()
+	};
 };
 
+/** @typedef {Node extends infer N ? (N extends Node ? N[keyof N] : never) : never} NodeFieldValue */
+
 /**
  * Checks if a value is an AST node.
- * @param {unknown} value candidate
- * @returns {value is Node} true when the value is an AST node
+ * @template V
+ * @param {V} value candidate
+ * @returns {value is Extract<V, Node>} true when the value is an AST node
  */
 const isNode = (value) =>
 	typeof value === "object" &&
 	value !== null &&
-	typeof (/** @type {{ type?: unknown }} */ (value).type) === "string";
+	typeof (/** @type {Partial<Node>} */ (value).type) === "string";
 
 /** Positional/metadata keys that never hold child AST nodes. */
 const NON_CHILD_KEYS = new Set([
@@ -284,8 +334,8 @@ const findOwnThisExpression = (body, params) => {
 				break;
 			default: {
 				const children =
-					/** @type {Record<string, unknown>} */
-					(/** @type {unknown} */ (node));
+					/** @type {Node & Record<string, NodeFieldValue>} */
+					(node);
 				const keys = getChildKeys(node);
 				for (let i = 0; i < keys.length; i++) {
 					const value = children[keys[i]];
@@ -358,12 +408,22 @@ const getObjectExportKind = (property) => {
 const PLUGIN_NAME = "CommonJsExportsParserPlugin";
 
 class CommonJsExportsParserPlugin {
+	/**
+	 * Creates an instance of CommonJsExportsParserPlugin.
+	 * @param {JavascriptParserOptions["topLevelThis"]} topLevelThis what top-level `this` refers to
+	 */
+	constructor(topLevelThis) {
+		/** @type {boolean} */
+		this.thisAsExports = topLevelThis !== "global";
+	}
+
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
+		const { thisAsExports } = this;
 		const enableStructuredExports = () => {
 			DynamicExports.enable(parser.state);
 		};
@@ -399,11 +459,11 @@ class CommonJsExportsParserPlugin {
 		 */
 		const bailoutHint = (reason) => {
 			recordOptimizationBailout(
-				/** @type {BuildInfo} */ (parser.state.module.buildInfo),
+				parser.state.module.buildInfo,
 				`CommonJS bailout: ${reason}`
 			);
 		};
-		/** @type {unknown} */
+		/** @type {JavascriptParser["state"] | undefined} */
 		let keptAllExportsForState;
 		/**
 		 * An exported function accessing its own `this` may reach any export
@@ -452,12 +512,14 @@ class CommonJsExportsParserPlugin {
 		 * @returns {boolean | undefined} true, when the expression was handled
 		 */
 		const handleAssignExport = (expr, base, members) => {
-			if (HarmonyExports.isEnabled(parser.state)) return;
-			// Handle reexporting
-			const requireCall = parseRequireCall(parser, expr.right);
+			if (ESMExports.isEnabled(parser.state)) return;
+			// Handle reexporting; `+=` and the like combine with the current value
+			const requireCall =
+				expr.operator === "="
+					? parseRequireCall(parser, expr.right)
+					: undefined;
 			if (
 				requireCall &&
-				requireCall.argument.isString() &&
 				(members.length === 0 || members[0] !== "__esModule")
 			) {
 				enableStructuredExports();
@@ -468,19 +530,21 @@ class CommonJsExportsParserPlugin {
 					null,
 					base,
 					members,
-					/** @type {string} */ (requireCall.argument.string),
+					requireCall.request,
 					requireCall.ids,
 					!parser.isStatementLevelExpression(expr)
 				);
+				if (requireCall.binding) {
+					dep.bindingRange = requireCall.binding.range;
+					dep.bindingDependency = requireCall.binding.dep;
+				}
 				dep.asiSafe = !parser.isAsiPosition(
 					/** @type {Range} */ (expr.range)[0]
 				);
 				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.module.addDependency(dep);
-				/** @type {JavascriptModuleBuildMeta} */ (
-					parser.state.module.buildMeta
-				).treatAsCommonJs = true;
+				parser.state.module.buildMeta.treatAsCommonJs = true;
 
 				return true;
 			}
@@ -505,9 +569,7 @@ class CommonJsExportsParserPlugin {
 			);
 			dep.loc = parser.getLocation(expr);
 			parser.state.module.addDependency(dep);
-			/** @type {JavascriptModuleBuildMeta} */ (
-				parser.state.module.buildMeta
-			).treatAsCommonJs = true;
+			parser.state.module.buildMeta.treatAsCommonJs = true;
 			keepAllExportsOnThisAccess(expr.right, base);
 			parser.walkExpression(expr.right);
 			return true;
@@ -531,9 +593,7 @@ class CommonJsExportsParserPlugin {
 			if (object.type !== "ObjectExpression") return;
 
 			const module = parser.state.module;
-			/** @type {JavascriptModuleBuildMeta} */ (
-				module.buildMeta
-			).treatAsCommonJs = true;
+			module.buildMeta.treatAsCommonJs = true;
 			// LHS stays as the text `module.exports` (moduleArgument is "module"
 			// unless a top-level `module` binding shadows it, which prevents this hook).
 			module.addPresentationalDependency(
@@ -598,10 +658,7 @@ class CommonJsExportsParserPlugin {
 					const usedByExports = new Set([name]);
 					for (let j = start; j < module.dependencies.length; j++) {
 						const nested = module.dependencies[j];
-						if (
-							nested instanceof CommonJsRequireDependency ||
-							nested instanceof CommonJsFullRequireDependency
-						) {
+						if (isDependencyKind(nested, "commonjs-require")) {
 							nested.usedByExports = usedByExports;
 						}
 					}
@@ -614,12 +671,14 @@ class CommonJsExportsParserPlugin {
 			.tap(PLUGIN_NAME, (expr, members) =>
 				handleAssignExport(expr, "exports", members)
 			);
-		parser.hooks.assignMemberChain
-			.for("this")
-			.tap(PLUGIN_NAME, (expr, members) => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAssignExport(expr, "this", members);
-			});
+		if (thisAsExports) {
+			parser.hooks.assignMemberChain
+				.for("this")
+				.tap(PLUGIN_NAME, (expr, members) => {
+					if (!parser.scope.topLevelScope) return;
+					return handleAssignExport(expr, "this", members);
+				});
+		}
 		parser.hooks.assignMemberChain
 			.for("module")
 			.tap(PLUGIN_NAME, (expr, members) => {
@@ -629,7 +688,7 @@ class CommonJsExportsParserPlugin {
 		parser.hooks.call
 			.for("Object.defineProperty")
 			.tap(PLUGIN_NAME, (expression) => {
-				const expr = /** @type {CallExpression} */ (expression);
+				const expr = expression;
 				if (!parser.isStatementLevelExpression(expr)) return;
 				if (expr.arguments.length !== 3) return;
 				if (expr.arguments[0].type === "SpreadElement") return;
@@ -640,7 +699,9 @@ class CommonJsExportsParserPlugin {
 				if (
 					exportsArg.identifier !== "exports" &&
 					exportsArg.identifier !== "module.exports" &&
-					(exportsArg.identifier !== "this" || !parser.scope.topLevelScope)
+					(exportsArg.identifier !== "this" ||
+						!thisAsExports ||
+						!parser.scope.topLevelScope)
 				) {
 					return;
 				}
@@ -655,26 +716,29 @@ class CommonJsExportsParserPlugin {
 					const reexport = getReexportOfPropertyDescriptor(descArg);
 					const requireCall =
 						reexport && parseRequireCall(parser, reexport.expr);
-					if (reexport && requireCall && requireCall.argument.isString()) {
+					if (reexport && requireCall) {
 						const dep = new CommonJsExportRequireDependency(
 							/** @type {Range} */ (expr.range),
 							/** @type {Range} */ (reexport.expr.range),
 							`Object.defineProperty(${exportsArg.identifier})`,
 							[property],
-							/** @type {string} */ (requireCall.argument.string),
+							requireCall.request,
 							requireCall.ids,
 							false
 						);
 						dep.getter = reexport.getter;
+						dep.descriptorStart = /** @type {Range} */ (descArg.range)[0];
+						if (requireCall.binding) {
+							dep.bindingRange = requireCall.binding.range;
+							dep.bindingDependency = requireCall.binding.dep;
+						}
 						dep.asiSafe = !parser.isAsiPosition(
 							/** @type {Range} */ (expr.range)[0]
 						);
 						dep.loc = parser.getLocation(expr);
 						dep.optional = Boolean(parser.scope.inTry);
 						parser.state.module.addDependency(dep);
-						/** @type {JavascriptModuleBuildMeta} */ (
-							parser.state.module.buildMeta
-						).treatAsCommonJs = true;
+						parser.state.module.buildMeta.treatAsCommonJs = true;
 
 						return true;
 					}
@@ -693,9 +757,7 @@ class CommonJsExportsParserPlugin {
 				);
 				dep.loc = parser.getLocation(expr);
 				parser.state.module.addDependency(dep);
-				/** @type {JavascriptModuleBuildMeta} */ (
-					parser.state.module.buildMeta
-				).treatAsCommonJs = true;
+				parser.state.module.buildMeta.treatAsCommonJs = true;
 
 				if (descArg.type === "ObjectExpression") {
 					// `value`, `get` and `set` descriptor functions are all called
@@ -724,7 +786,7 @@ class CommonJsExportsParserPlugin {
 		 * @returns {boolean | void} true, when the expression was handled
 		 */
 		const handleAccessExport = (expr, base, members, call) => {
-			if (HarmonyExports.isEnabled(parser.state)) return;
+			if (ESMExports.isEnabled(parser.state)) return;
 			if (members.length === 0) {
 				bailout(
 					`${base} is used directly at ${formatLocation(
@@ -749,9 +811,7 @@ class CommonJsExportsParserPlugin {
 			);
 			dep.loc = parser.getLocation(expr);
 			parser.state.module.addDependency(dep);
-			/** @type {JavascriptModuleBuildMeta} */ (
-				parser.state.module.buildMeta
-			).treatAsCommonJs = true;
+			parser.state.module.buildMeta.treatAsCommonJs = true;
 
 			if (call) {
 				parser.walkExpressions(call.arguments);
@@ -793,27 +853,29 @@ class CommonJsExportsParserPlugin {
 			.tap(PLUGIN_NAME, (expr) =>
 				handleAccessExport(expr, "module.exports", [])
 			);
-		parser.hooks.callMemberChain
-			.for("this")
-			.tap(PLUGIN_NAME, (expr, members) => {
+		if (thisAsExports) {
+			parser.hooks.callMemberChain
+				.for("this")
+				.tap(PLUGIN_NAME, (expr, members) => {
+					if (!parser.scope.topLevelScope) return;
+					return handleAccessExport(expr.callee, "this", members, expr);
+				});
+			parser.hooks.expressionMemberChain
+				.for("this")
+				.tap(PLUGIN_NAME, (expr, members) => {
+					if (!parser.scope.topLevelScope) return;
+					return handleAccessExport(expr, "this", members);
+				});
+			parser.hooks.expression.for("this").tap(PLUGIN_NAME, (expr) => {
 				if (!parser.scope.topLevelScope) return;
-				return handleAccessExport(expr.callee, "this", members, expr);
+				return handleAccessExport(expr, "this", []);
 			});
-		parser.hooks.expressionMemberChain
-			.for("this")
-			.tap(PLUGIN_NAME, (expr, members) => {
-				if (!parser.scope.topLevelScope) return;
-				return handleAccessExport(expr, "this", members);
-			});
-		parser.hooks.expression.for("this").tap(PLUGIN_NAME, (expr) => {
-			if (!parser.scope.topLevelScope) return;
-			return handleAccessExport(expr, "this", []);
-		});
+		}
 
 		// Bailouts //
 		parser.hooks.expression.for("module").tap(PLUGIN_NAME, (expr) => {
-			const isHarmony = HarmonyExports.isEnabled(parser.state);
-			// Silent under ESM, where `HarmonyExports` governs and nothing was lost.
+			const isHarmony = ESMExports.isEnabled(parser.state);
+			// Silent under ESM, where `ESMExports` governs and nothing was lost.
 			bailout(
 				isHarmony
 					? undefined
@@ -823,7 +885,7 @@ class CommonJsExportsParserPlugin {
 			);
 			const dep = new ModuleDecoratorDependency(
 				isHarmony
-					? RuntimeGlobals.harmonyModuleDecorator
+					? RuntimeGlobals.esmModuleDecorator
 					: RuntimeGlobals.nodeModuleDecorator,
 				!isHarmony
 			);

package/lib/dependencies/{CommonJsFullRequireDependency.js → commonjs/CommonJsFullRequireDependency.js}

@@ -5,39 +5,40 @@
 
 "use strict";
 
-const Template = require("../Template");
 const {
 	getDependencyUsedByExportsCondition
-} = require("../optimize/InnerGraph");
-const { equals } = require("../util/ArrayHelpers");
-const { getTrimmedIdsAndRange } = require("../util/chainedImports");
-const makeSerializable = require("../util/makeSerializable");
-const { propertyAccess } = require("../util/property");
+} = require("../../optimize/InnerGraph");
+const Template = require("../../template/Template");
+const { equals } = require("../../util/ArrayHelpers");
+const makeSerializable = require("../../util/makeSerializable");
+const { propertyAccess } = require("../../util/property");
+const ModuleDependency = require("../core/ModuleDependency");
+const ESMImportGuard = require("../esm/ESMImportGuard");
+const { getTrimmedIdsAndRange } = require("../helpers/chainedImports");
 const {
 	ESM_MODULE_EXPORTS_NAME,
 	getRequireEsmModuleExportsAccess,
 	isRequireEsmModuleExportsModule
 } = require("./CommonJsDependencyHelpers");
-const HarmonyImportGuard = require("./HarmonyImportGuard");
-const ModuleDependency = require("./ModuleDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
 /**
  * @import Dependency, {
  * 	GetConditionFn,
  * 	ReferencedExports,
- * 	ExportInfoName
- * } from "../Dependency"
+ * 	ExportInfoName,
+ * 	DependencyKinds
+ * } from "../../graph/Dependency"
  */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import { Range } from "../javascript/JavascriptParser" */
-/** @import { UsedByExports } from "../optimize/InnerGraph" */
-/** @import { RuntimeSpec } from "../util/runtime" */
-/** @import { IdRanges } from "../util/chainedImports" */
-/** @import { DependencyGuard } from "./HarmonyImportGuard" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectSerializerContext */
+/** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
+/** @import ModuleGraph from "../../graph/ModuleGraph" */
+/** @import { Range } from "../../javascript/JavascriptParser" */
+/** @import { UsedByExports } from "../../optimize/InnerGraph" */
+/** @import { RuntimeSpec } from "../../util/runtime" */
+/** @import { IdRanges } from "../helpers/chainedImports" */
+/** @import { DependencyGuard } from "../esm/ESMImportGuard" */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectSerializerContext */
 
 class CommonJsFullRequireDependency extends ModuleDependency {
 	/**
@@ -51,7 +52,7 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 		request,
 		range,
 		names,
-		idRanges /* TODO webpack 6 make this non-optional. It must always be set to properly trim ids. */
+		idRanges /* TODO in the next major release: make this non-optional. It must always be set to properly trim ids. */
 	) {
 		super(request);
 		this.range = range;
@@ -95,7 +96,7 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 			}
 			return !(
 				guards !== undefined &&
-				HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+				ESMImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
 			);
 		};
 	}
@@ -303,9 +304,16 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 	}
 };
 
-makeSerializable(
-	CommonJsFullRequireDependency,
+makeSerializable(CommonJsFullRequireDependency, [
+	"webpack/lib/dependencies/commonjs/CommonJsFullRequireDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/CommonJsFullRequireDependency"
-);
+]);
+
+/** @type {Set<keyof DependencyKinds>} */
+CommonJsFullRequireDependency.KINDS = new Set([
+	...ModuleDependency.KINDS,
+	"commonjs-require"
+]);
 
 module.exports = CommonJsFullRequireDependency;