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

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -11,27 +11,57 @@ const formatLocation = require("../util/formatLocation");
 const { propertyAccess } = require("../util/property");
 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");
 
-/** @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 */
-/** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../javascript/JavascriptParser").Members} Members */
-/** @typedef {import("../javascript/JavascriptParser").StatementPath} StatementPath */
-/** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
+const FUNCTION_PROPERTY_DROP_HEAD =
+	CommonJsObjectExportDependency.FUNCTION_PROPERTY_DROP_HEAD;
+
+/**
+ * @import {
+ * 	AssignmentExpression,
+ * 	CallExpression,
+ * 	Expression,
+ * 	FunctionExpression,
+ * 	Node,
+ * 	ObjectExpression,
+ * 	Property,
+ * 	SpreadElement,
+ * 	Super,
+ * 	ThisExpression
+ * } from "estree"
+ */
+/** @import { ExportInfoName } from "../Dependency" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
+/**
+ * @import JavascriptParser, {
+ * 	Range,
+ * 	Members,
+ * 	StatementPath
+ * } from "../javascript/JavascriptParser"
+ */
+/**
+ * @import {
+ * 	CommonJSDependencyBaseKeywords
+ * } from "./CommonJsDependencyHelpers"
+ */
+/**
+ * @import {
+ * 	CommonJsObjectExportKind
+ * } from "./CommonJsObjectExportDependency"
+ */
+/**
+ * @import {
+ * 	JavascriptModuleBuildMeta
+ * } from "../javascript/JavascriptModule"
+ */
 
 /**
  * This function takes a generic expression and detects whether it is an ObjectExpression.
@@ -230,11 +260,15 @@ const getChildKeys = (node) => {
  * 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
+ * @param {Node} body function body
+ * @param {Node[]} params function params
  * @returns {ThisExpression | undefined} first own `this` expression
  */
-const findOwnThisExpression = (initialNodes) => {
-	const stack = [...initialNodes];
+const findOwnThisExpression = (body, params) => {
+	// the body is popped first, so its `this` wins over a default parameter's
+	const stack = [];
+	for (let i = 0; i < params.length; i++) stack.push(params[i]);
+	stack.push(body);
 	let node;
 	while ((node = stack.pop()) !== undefined) {
 		switch (node.type) {
@@ -271,14 +305,55 @@ const findOwnThisExpression = (initialNodes) => {
  * 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 {JavascriptParser} parser the parser
  * @param {Node} expr the exported value
  * @returns {ThisExpression | undefined} first own `this` expression
  */
-const getThisAccessInExportedValue = (expr) =>
-	expr.type === "FunctionExpression"
-		? findOwnThisExpression([...expr.params, expr.body])
+const getThisAccessInExportedValue = (parser, expr) =>
+	expr.type === "FunctionExpression" &&
+	// scanning the body of every exported function is expensive and most of them
+	// never mention `this`, so filter on the source text first
+	parser.sourceMayContainIdentifier(/** @type {Range} */ (expr.range), "this")
+		? findOwnThisExpression(expr.body, expr.params)
 		: undefined;
 
+/**
+ * Returns the export name an object-literal property contributes, or
+ * `undefined` when it cannot contribute one: a spread, a computed or
+ * non-string key is unknown at compile time, and `__proto__` sets
+ * [[Prototype]] instead of an own property.
+ * @param {Property | SpreadElement} property property
+ * @returns {string | undefined} export name
+ */
+const getStaticPropertyName = (property) => {
+	if (property.type === "SpreadElement" || property.computed) return;
+	const key = property.key;
+	/** @type {string | undefined} */
+	let name;
+	if (key.type === "Identifier") {
+		name = key.name;
+	} else if (key.type === "Literal" && typeof key.value === "string") {
+		name = key.value;
+	}
+	return name === "__proto__" ? undefined : name;
+};
+
+/**
+ * @param {Property} property property
+ * @returns {CommonJsObjectExportKind} property kind
+ */
+const getObjectExportKind = (property) => {
+	if (property.kind === "get" || property.kind === "set") return property.kind;
+	if (property.method) {
+		const { async, generator } = /** @type {FunctionExpression} */ (
+			property.value
+		);
+		if (async) return generator ? "asyncGeneratorMethod" : "asyncMethod";
+		return generator ? "generatorMethod" : "method";
+	}
+	return property.shorthand ? "shorthand" : "keyValue";
+};
+
 const PLUGIN_NAME = "CommonJsExportsParserPlugin";
 
 class CommonJsExportsParserPlugin {
@@ -348,7 +423,7 @@ class CommonJsExportsParserPlugin {
 		const keepAllExportsOnThisAccess = (valueExpr, base) => {
 			// One bailout per module is enough
 			if (keptAllExportsForState === parser.state) return;
-			const thisExpr = getThisAccessInExportedValue(valueExpr);
+			const thisExpr = getThisAccessInExportedValue(parser, valueExpr);
 			if (thisExpr === undefined) return;
 			keptAllExportsForState = parser.state;
 			bailoutHint(
@@ -413,7 +488,10 @@ class CommonJsExportsParserPlugin {
 
 				return true;
 			}
-			if (members.length === 0) return;
+			// `module.exports = { … }` — properties are the module's named exports.
+			if (members.length === 0) {
+				return handleObjectLiteralExport(expr, base);
+			}
 			enableStructuredExports();
 			const remainingMembers = members;
 			checkNamespace(
@@ -438,6 +516,103 @@ class CommonJsExportsParserPlugin {
 			parser.walkExpression(expr.right);
 			return true;
 		};
+		/**
+		 * Handle top-level `module.exports = { … }` object-literal exports.
+		 * @param {AssignmentExpression} expr expression
+		 * @param {CommonJSDependencyBaseKeywords} base commonjs base keywords
+		 * @returns {boolean | undefined} true, when the expression was handled
+		 */
+		const handleObjectLiteralExport = (expr, base) => {
+			// Only `module.exports = { … }` replaces the whole exports object.
+			if (base !== "module.exports") return;
+			if (
+				/** @type {StatementPath} */ (parser.statementPath).length !== 1 ||
+				!parser.isStatementLevelExpression(expr)
+			) {
+				return;
+			}
+			const object = expr.right;
+			if (object.type !== "ObjectExpression") return;
+
+			const module = parser.state.module;
+			/** @type {JavascriptModuleBuildMeta} */ (
+				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(
+				new RuntimeRequirementsDependency([RuntimeGlobals.module])
+			);
+
+			// one unknown key makes the whole object opaque, so name them all first
+			/** @type {string[]} */
+			const names = [];
+			for (const property of object.properties) {
+				const name = getStaticPropertyName(property);
+				if (name === undefined) {
+					bailout(
+						`module.exports = {…} cannot be statically analysed at ${formatLocation(
+							parser.getLocation(expr)
+						)}`
+					);
+					parser.walkExpression(object);
+					return true;
+				}
+				names.push(name);
+			}
+
+			enableStructuredExports();
+
+			for (let i = 0; i < object.properties.length; i++) {
+				const property = /** @type {Property} */ (object.properties[i]);
+				const name = names[i];
+				const value = /** @type {Expression} */ (property.value);
+				const kind = getObjectExportKind(property);
+				// a shorthand has no value text of its own to replace
+				const valueRange = /** @type {Range} */ (
+					kind === "shorthand" ? property.range : value.range
+				);
+				// scans the key/value gap, so `/*#__PURE__*/` is picked up here
+				const pure =
+					kind === "keyValue" &&
+					parser.isPure(value, /** @type {Range} */ (property.key.range)[1]);
+
+				if (name === "__esModule") {
+					checkNamespace(true, ["__esModule"], value);
+				}
+
+				const dep = new CommonJsObjectExportDependency(
+					/** @type {Range} */ (property.range),
+					/** @type {Range} */ (property.key.range),
+					valueRange,
+					name,
+					kind,
+					pure
+				);
+				dep.loc = parser.getLocation(property);
+				module.addDependency(dep);
+
+				keepAllExportsOnThisAccess(value, base);
+				// Tag nested requires so unused get/set/method can disconnect them.
+				const start = FUNCTION_PROPERTY_DROP_HEAD.has(kind)
+					? module.dependencies.length
+					: -1;
+				parser.walkExpression(value);
+				if (start !== -1) {
+					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
+						) {
+							nested.usedByExports = usedByExports;
+						}
+					}
+				}
+			}
+			return true;
+		};
 		parser.hooks.assignMemberChain
 			.for("exports")
 			.tap(PLUGIN_NAME, (expr, members) =>
@@ -638,8 +813,15 @@ class CommonJsExportsParserPlugin {
 
 		// Bailouts //
 		parser.hooks.expression.for("module").tap(PLUGIN_NAME, (expr) => {
-			bailout();
 			const isHarmony = HarmonyExports.isEnabled(parser.state);
+			// Silent under ESM, where `HarmonyExports` governs and nothing was lost.
+			bailout(
+				isHarmony
+					? undefined
+					: `module is used directly at ${formatLocation(
+							parser.getLocation(expr)
+						)}`
+			);
 			const dep = new ModuleDecoratorDependency(
 				isHarmony
 					? RuntimeGlobals.harmonyModuleDecorator

package/lib/dependencies/CommonJsFullRequireDependency.js

@@ -6,33 +6,38 @@
 "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 memoize = require("../util/memoize");
 const { propertyAccess } = require("../util/property");
 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")} Dependency */
-/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
-/** @typedef {import("./HarmonyImportGuard").DependencyGuard} DependencyGuard */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined]>} ObjectSerializerContext */
-
-const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
+/** @import { ReplaceSource } from "webpack-sources" */
+/**
+ * @import Dependency, {
+ * 	GetConditionFn,
+ * 	ReferencedExports,
+ * 	ExportInfoName
+ * } from "../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 */
 
 class CommonJsFullRequireDependency extends ModuleDependency {
 	/**
@@ -56,10 +61,16 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 		this.idRanges = idRanges;
 		/** @type {boolean} */
 		this.call = false;
+		/** @type {boolean} */
+		this.namespaceObjectAsContext = false;
 		/** @type {undefined | boolean} */
 		this.asiSafe = undefined;
 		/** @type {DependencyGuard[] | undefined} */
 		this.branchGuards = undefined;
+		/** @type {UsedByExports | undefined} */
+		this.usedByExports = undefined;
+		/** @type {boolean} */
+		this._canConcatenate = false;
 	}
 
 	/**
@@ -68,10 +79,34 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 	 * @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);
+		if (usedByExportsCondition === null && guards === undefined) return null;
+		return (connection, runtime) => {
+			if (
+				usedByExportsCondition !== null &&
+				usedByExportsCondition(connection, runtime) === false
+			) {
+				return false;
+			}
+			return !(
+				guards !== undefined &&
+				HarmonyImportGuard.isDeadByGuards(guards, moduleGraph, runtime)
+			);
+		};
+	}
+
+	/**
+	 * 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;
 	}
 
 	/**
@@ -95,6 +130,8 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 		if (
 			this.call &&
 			(!importedModule ||
+				// the namespace object of a required ESM module is the call receiver
+				this.namespaceObjectAsContext ||
 				importedModule.getExportsType(moduleGraph, false) !== "namespace")
 		) {
 			return [{ name: this.names.slice(0, -1), canInline: false }];
@@ -112,7 +149,10 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 			.write(this.idRanges)
 			.write(this.call)
 			.write(this.asiSafe)
-			.write(this.branchGuards);
+			.write(this.branchGuards)
+			.write(this._canConcatenate)
+			.write(this.namespaceObjectAsContext)
+			.write(this.usedByExports);
 		super.serialize(context);
 	}
 
@@ -130,7 +170,13 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 		this.asiSafe = c3.read();
 		const c4 = c3.rest;
 		this.branchGuards = c4.read();
-		super.deserialize(c4.rest);
+		const c5 = c4.rest;
+		this._canConcatenate = c5.read();
+		const c6 = c5.rest;
+		this.namespaceObjectAsContext = c6.read();
+		const c7 = c6.rest;
+		this.usedByExports = c7.read();
+		super.deserialize(c7.rest);
 	}
 
 	get type() {
@@ -155,7 +201,14 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 	apply(
 		dependency,
 		source,
-		{ runtimeTemplate, moduleGraph, chunkGraph, runtimeRequirements, runtime }
+		{
+			runtimeTemplate,
+			moduleGraph,
+			chunkGraph,
+			runtimeRequirements,
+			runtime,
+			concatenationScope
+		}
 	) {
 		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
 		if (!dep.range) return;
@@ -167,17 +220,6 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 			return;
 		}
 		const importedModule = moduleGraph.getModule(dep);
-		let requireExpr = runtimeTemplate.moduleExports({
-			module: importedModule,
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
-
-		const esmRequireAccess = importedModule
-			? getRequireEsmModuleExportsAccess(importedModule, moduleGraph, runtime)
-			: null;
 
 		const {
 			trimmedRange: [trimmedRangeStart, trimmedRangeEnd],
@@ -190,6 +232,49 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 			dep
 		);
 
+		if (concatenationScope) {
+			const connection = moduleGraph.getConnection(dep);
+			if (
+				connection &&
+				importedModule &&
+				concatenationScope.isModuleInScope(importedModule)
+			) {
+				// `require(esm)` unwraps the "module.exports" export and the member
+				// chain hangs off it; without that prefix the ids name exports the
+				// module never declares.
+				const ids = isRequireEsmModuleExportsModule(
+					connection.module,
+					moduleGraph
+				)
+					? [ESM_MODULE_EXPORTS_NAME, ...trimmedIds]
+					: trimmedIds;
+
+				source.replace(
+					trimmedRangeStart,
+					trimmedRangeEnd - 1,
+					concatenationScope.createModuleReference(connection.module, {
+						ids: ids.length > 0 ? ids : undefined,
+						call: dep.call,
+						asiSafe: dep.asiSafe,
+						moduleExportsAccess: true
+					})
+				);
+				return;
+			}
+		}
+
+		let requireExpr = runtimeTemplate.moduleExports({
+			module: importedModule,
+			chunkGraph,
+			request: dep.request,
+			weak: dep.weak,
+			runtimeRequirements
+		});
+
+		const esmRequireAccess = importedModule
+			? getRequireEsmModuleExportsAccess(importedModule, moduleGraph, runtime)
+			: null;
+
 		if (esmRequireAccess !== null) {
 			const access = `${esmRequireAccess}${propertyAccess(trimmedIds)}`;
 			requireExpr =
@@ -197,7 +282,7 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 					? `(${requireExpr}${access})`
 					: `${requireExpr}${access}`;
 		} else if (importedModule) {
-			// CJS exports are never inlined
+			// CJS required are never inlined
 			const usedImported = /** @type {string | string[] | false} */ (
 				moduleGraph
 					.getExportsInfo(importedModule)