@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/dependencies/BuildTimeConstDependency.js

@@ -0,0 +1,102 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ConstDependency = require("./ConstDependency");
+const NullDependency = require("./NullDependency");
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { UpdateHashContext } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import Hash from "../util/Hash" */
+
+/**
+ * A constant replacement whose source is only valid in emitted output (e.g.
+ * native `import.meta`), with a separate expression for build-time execution.
+ */
+class BuildTimeConstDependency extends ConstDependency {
+	/**
+	 * Creates an instance of BuildTimeConstDependency.
+	 * @param {string} expression the expression
+	 * @param {string} buildTimeExpression the expression for build-time execution
+	 * @param {Range} range the source range
+	 * @param {(string[] | null)=} runtimeRequirements runtime requirements
+	 */
+	constructor(expression, buildTimeExpression, range, runtimeRequirements) {
+		super(expression, range, runtimeRequirements);
+		/** @type {string} */
+		this.buildTimeExpression = buildTimeExpression;
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		hash.update(this.buildTimeExpression);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.buildTimeExpression);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.buildTimeExpression = context.read();
+		super.deserialize(context.rest);
+	}
+}
+
+makeSerializable(
+	BuildTimeConstDependency,
+	"webpack/lib/dependencies/BuildTimeConstDependency"
+);
+
+BuildTimeConstDependency.Template = class BuildTimeConstDependencyTemplate extends (
+	NullDependency.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, templateContext) {
+		const dep = /** @type {BuildTimeConstDependency} */ (dependency);
+		if (dep.runtimeRequirements) {
+			for (const req of dep.runtimeRequirements) {
+				templateContext.runtimeRequirements.add(req);
+			}
+		}
+		const expression = templateContext.chunkGraph.buildTimeExecution
+			? dep.buildTimeExpression
+			: dep.expression;
+		const range = /** @type {Range} */ (dep.range);
+		source.replace(range[0], range[1] - 1, expression);
+	}
+};
+
+module.exports = BuildTimeConstDependency;

package/lib/dependencies/CachedConstDependency.js

@@ -10,14 +10,17 @@ const InitFragment = require("../InitFragment");
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency")} Dependency */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { UpdateHashContext } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import Hash from "../util/Hash" */
 
 class CachedConstDependency extends NullDependency {
 	/**

package/lib/dependencies/CommonJsDependencyHelpers.js

@@ -5,17 +5,15 @@
 
 "use strict";
 
-const InitFragment = require("../InitFragment");
+const Entrypoint = require("../Entrypoint");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
 const { propertyAccess } = require("../util/property");
 
-/** @typedef {import("../ConcatenationScope")} ConcatenationScope */
-/** @typedef {import("../Generator").GenerateContext} GenerateContext */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Module, { RuntimeRequirements } from "../Module" */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 /** @typedef {"exports" | "module.exports" | "this" | "Object.defineProperty(exports)" | "Object.defineProperty(module.exports)" | "Object.defineProperty(this)"} CommonJSDependencyBaseKeywords */
 
 /**
@@ -75,54 +73,65 @@ const getRequireEsmModuleExportsAccess = (
 
 module.exports.ESM_MODULE_EXPORTS_NAME = ESM_MODULE_EXPORTS_NAME;
 
+module.exports.getRequireEsmModuleExportsAccess =
+	getRequireEsmModuleExportsAccess;
+
 /**
- * Rewrites an `exports.<names>` reference of a concatenated CommonJS module to
- * a hoisted module-scope variable and registers that variable as the export's
- * symbol, so other concatenated modules bind to it directly.
- * @param {ConcatenationScope} concatenationScope the concatenation scope
- * @param {InitFragment<GenerateContext>[]} initFragments init fragments (receives the `var` declaration)
- * @param {string[]} names full member chain of the reference (at least one entry)
- * @returns {string} replacement expression for the whole reference
+ * Whether the base keyword reads the module's top-level `this`.
+ * @param {CommonJSDependencyBaseKeywords} depBase commonjs dependency base
+ * @returns {boolean} true when the base is `this`
  */
-module.exports.getConcatenatedExportAccess = (
-	concatenationScope,
-	initFragments,
-	names
-) => {
-	const name = names[0];
-	const identifier = Template.toIdentifier(name);
-	// A sanitized name could collide with another export ("a-b" vs "a_b"),
-	// so non-identifier names get a hex suffix of the raw name.
-	const symbol = `__WEBPACK_CJS_EXPORT_${
-		identifier === name
-			? name
-			: `${identifier}_${Buffer.from(name, "utf8").toString("hex")}`
-	}__`;
-	initFragments.push(
-		new InitFragment(
-			`var ${symbol};\n`,
-			InitFragment.STAGE_CONSTANTS,
-			0,
-			`cjs concatenated export ${name}`
-		)
-	);
-	concatenationScope.registerExport(name, symbol);
-	return `${symbol}${propertyAccess(names, 1)}`;
+const isThisBase = (depBase) =>
+	depBase === "this" || depBase === "Object.defineProperty(this)";
+
+/**
+ * A classic worker script's top-level `this` is its global scope, not the
+ * module's exports. True only for a runtime every entry of which is a worker,
+ * so a module imported elsewhere keeps exports semantics in that runtime.
+ * @param {Module} module the module
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {RuntimeSpec} runtime the runtime code is generated for
+ * @param {RuntimeTemplate=} runtimeTemplate the runtime template
+ * @returns {boolean} true when `this` is the worker's global scope
+ */
+const isWorkerEntryThis = (module, chunkGraph, runtime, runtimeTemplate) => {
+	// a module worker or worklet is an ES module, where `this` is undefined and
+	// there is nothing to resolve it to
+	if (
+		typeof runtime !== "string" ||
+		runtimeTemplate === undefined ||
+		runtimeTemplate.isModule()
+	) {
+		return false;
+	}
+	let workerEntry = false;
+	for (const chunk of chunkGraph.getModuleChunks(module)) {
+		if (chunk.runtime !== runtime) continue;
+		for (const group of chunk.groupsIterable) {
+			if (!(group instanceof Entrypoint)) continue;
+			const { options } = group;
+			// an entry may pin a worker to a non-worker entry's runtime, leaving one
+			// code generation for both roles: keep exports, the only safe answer
+			if (!options.worker || options.worklet) return false;
+			workerEntry = true;
+		}
+	}
+	return workerEntry;
 };
-module.exports.getRequireEsmModuleExportsAccess =
-	getRequireEsmModuleExportsAccess;
 
 /**
  * Returns type and base.
  * @param {CommonJSDependencyBaseKeywords} depBase commonjs dependency base
  * @param {Module} module module
  * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+ * @param {boolean=} isWorkerEntry whether `this` is a classic worker's global scope
  * @returns {[string, string]} type and base
  */
 module.exports.handleDependencyBase = (
 	depBase,
 	module,
-	runtimeRequirements
+	runtimeRequirements,
+	isWorkerEntry
 ) => {
 	/** @type {string} */
 	let base;
@@ -140,8 +149,13 @@ module.exports.handleDependencyBase = (
 			type = "expression";
 			break;
 		case "this":
-			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-			base = "this";
+			if (isWorkerEntry) {
+				runtimeRequirements.add(RuntimeGlobals.global);
+				base = RuntimeGlobals.global;
+			} else {
+				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+				base = "this";
+			}
 			type = "expression";
 			break;
 		case "Object.defineProperty(exports)":
@@ -155,8 +169,13 @@ module.exports.handleDependencyBase = (
 			type = "Object.defineProperty";
 			break;
 		case "Object.defineProperty(this)":
-			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
-			base = "this";
+			if (isWorkerEntry) {
+				runtimeRequirements.add(RuntimeGlobals.global);
+				base = RuntimeGlobals.global;
+			} else {
+				runtimeRequirements.add(RuntimeGlobals.thisAsExports);
+				base = "this";
+			}
 			type = "Object.defineProperty";
 			break;
 		default:
@@ -167,3 +186,5 @@ module.exports.handleDependencyBase = (
 };
 module.exports.isRequireEsmModuleExportsModule =
 	isRequireEsmModuleExportsModule;
+module.exports.isThisBase = isThisBase;
+module.exports.isWorkerEntryThis = isWorkerEntryThis;

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -20,20 +20,29 @@ const {
 const ModuleDependency = require("./ModuleDependency");
 const processExportInfo = require("./processExportInfo");
 
-/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
-/** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
-/** @typedef {import("../Dependency").RawReferencedExports} RawReferencedExports */
-/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
-/** @typedef {import("../Dependency").TRANSITIVE} TRANSITIVE */
-/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
-/** @typedef {import("../ExportsInfo")} ExportsInfo */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./CommonJsDependencyHelpers").CommonJSDependencyBaseKeywords} CommonJSDependencyBaseKeywords */
+/** @import { ReplaceSource } from "webpack-sources" */
+/**
+ * @import {
+ * 	ExportsSpec,
+ * 	GetConditionFn,
+ * 	RawReferencedExports,
+ * 	ReferencedExports,
+ * 	TRANSITIVE,
+ * 	ExportInfoName
+ * } from "../Dependency"
+ */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import ExportsInfo, { ExportInfo } from "../ExportsInfo" */
+/** @import Module from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/**
+ * @import {
+ * 	CommonJSDependencyBaseKeywords
+ * } from "./CommonJsDependencyHelpers"
+ */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[undefined | boolean, Range, Range | null, CommonJSDependencyBaseKeywords, ExportInfoName[], ExportInfoName[], boolean, boolean]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[undefined | boolean, Range, Range | null, CommonJSDependencyBaseKeywords, ExportInfoName[], ExportInfoName[], boolean, boolean]>} ObjectSerializerContext */
 
@@ -93,6 +102,40 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		return Dependency.TRANSITIVE;
 	}
 
+	/**
+	 * Returns true if this dependency can be concatenated
+	 * @param {boolean} concatenateCommonJsModules whether optimization.concatenateModules.commonjs is enabled
+	 * @returns {boolean} true if this dependency can be concatenated
+	 */
+	canConcatenate(concatenateCommonJsModules) {
+		return concatenateCommonJsModules;
+	}
+
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		// Conservative: keep `module.exports = require(...)` (names empty) active even
+		// when the parent is evaluation-only and the target is side-effect-free.
+		if (this.resultUsed || this.names.length === 0) return null;
+		const names = this.names;
+		const getter = this.getter;
+		return (connection, runtime) => {
+			const parentModule = moduleGraph.getParentModule(this);
+			if (!parentModule) return true;
+			const used = moduleGraph
+				.getExportsInfo(parentModule)
+				.getUsedName(names, runtime);
+			if (used !== false) return true;
+			if (getter) return false;
+			const refModule = connection.resolvedModule;
+			if (!refModule) return true;
+			return refModule.getSideEffectsConnectionState(moduleGraph);
+		};
+	}
+
 	/**
 	 * Returns the imported id.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -149,7 +192,7 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		);
 		for (const name of this.names) {
 			const exportInfo =
-				/** @type {ExportInfo} */
+				/** @type {InstanceType<ExportInfo>} */
 				(exportsInfo.getReadOnlyExportInfo(name));
 			const used = exportInfo.getUsed(runtime);
 			if (used === UsageState.Unused) return Dependency.NO_EXPORTS_REFERENCED;
@@ -240,6 +283,25 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 				dependencies: [from.module]
 			};
 		}
+		// The imported namespace ESM hasn't been flagged by
+		// FlagDependencyExportsPlugin yet (no exports determined), so its
+		// `"module.exports"` unwrap eligibility is still unknown. Star-reexporting
+		// now would add `__esModule` (and names) the monotonic merge can't retract
+		// once the module turns out to unwrap, making the result order-dependent
+		// across runtimes; defer — the `from.module` dependency re-queues us once
+		// its exports (owned names, or dynamic `other`) become known.
+		if (
+			importedModule &&
+			importedModule.getExportsType(moduleGraph, false) === "namespace"
+		) {
+			const importedExportsInfo = moduleGraph.getExportsInfo(importedModule);
+			if (
+				importedExportsInfo.otherExportsInfo.provided === false &&
+				importedExportsInfo.ownedExports[Symbol.iterator]().next().done
+			) {
+				return { exports: [], dependencies: [from.module] };
+			}
+		}
 		const reexportInfo = this.getStarReexports(
 			moduleGraph,
 			undefined,
@@ -421,7 +483,8 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 			chunkGraph,
 			moduleGraph,
 			runtimeRequirements,
-			runtime
+			runtime,
+			concatenationScope
 		}
 	) {
 		const dep = /** @type {CommonJsExportRequireDependency} */ (dependency);
@@ -430,6 +493,16 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 			moduleGraph.getExportsInfo(module).getUsedName(dep.names, runtime)
 		);
 
+		const connection = /** @type {ModuleGraphConnection | undefined} */ (
+			moduleGraph.getConnection(dep)
+		);
+		// Inactive unused reexport: no module id; drop to a no-op.
+		// Missing connection (e.g. IgnorePlugin) must keep the require so it throws.
+		if (!used && connection && !connection.isTargetActive(runtime)) {
+			source.replace(dep.range[0], dep.range[1] - 1, "/* unused reexport */ 0");
+			return;
+		}
+
 		const [type, base] = handleDependencyBase(
 			dep.base,
 			module,
@@ -437,32 +510,55 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 		);
 
 		const importedModule = moduleGraph.getModule(dep);
-		let requireExpr = runtimeTemplate.moduleExports({
-			module: importedModule,
-			chunkGraph,
-			request: dep.request,
-			weak: dep.weak,
-			runtimeRequirements
-		});
-		if (importedModule) {
+		/** @type {string} */
+		let requireExpr;
+		if (
+			concatenationScope &&
+			importedModule &&
+			concatenationScope.isModuleInScope(importedModule)
+		) {
+			// The alias reads the target's exports value, so it binds like `require()`
+			// rather than an ESM import: no interop.
 			const ids = dep.getIds(moduleGraph);
-			const esmRequireAccess = getRequireEsmModuleExportsAccess(
+			const requestedIds = isRequireEsmModuleExportsModule(
 				importedModule,
-				moduleGraph,
-				runtime
-			);
-			if (esmRequireAccess !== null) {
-				requireExpr += `${esmRequireAccess}${propertyAccess(ids)}`;
-			} else {
-				// CJS exports are never inlined
-				const usedImported = /** @type {string | string[] | false} */ (
-					moduleGraph.getExportsInfo(importedModule).getUsedName(ids, runtime)
+				moduleGraph
+			)
+				? [ESM_MODULE_EXPORTS_NAME, ...ids]
+				: ids;
+			requireExpr = concatenationScope.createModuleReference(importedModule, {
+				ids: requestedIds.length > 0 ? requestedIds : undefined,
+				asiSafe: true,
+				moduleExportsAccess: true
+			});
+		} else {
+			requireExpr = runtimeTemplate.moduleExports({
+				module: importedModule,
+				chunkGraph,
+				request: dep.request,
+				weak: dep.weak,
+				runtimeRequirements
+			});
+			if (importedModule) {
+				const ids = dep.getIds(moduleGraph);
+				const esmRequireAccess = getRequireEsmModuleExportsAccess(
+					importedModule,
+					moduleGraph,
+					runtime
 				);
-				if (usedImported) {
-					const comment = equals(usedImported, ids)
-						? ""
-						: `${Template.toNormalComment(propertyAccess(ids))} `;
-					requireExpr += `${comment}${propertyAccess(/** @type {string[]} */ (usedImported))}`;
+				if (esmRequireAccess !== null) {
+					requireExpr += `${esmRequireAccess}${propertyAccess(ids)}`;
+				} else {
+					// CJS exports are never inlined
+					const usedImported = /** @type {string | string[] | false} */ (
+						moduleGraph.getExportsInfo(importedModule).getUsedName(ids, runtime)
+					);
+					if (usedImported) {
+						const comment = equals(usedImported, ids)
+							? ""
+							: `${Template.toNormalComment(propertyAccess(ids))} `;
+						requireExpr += `${comment}${propertyAccess(/** @type {string[]} */ (usedImported))}`;
+					}
 				}
 			}
 		}
@@ -483,14 +579,12 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 				// barrel files (e.g. webpack's own `lib/index.js`).
 				const valueRange = /** @type {Range} */ (dep.valueRange);
 				if (!used) {
-					// A lazy getter never runs `require` until accessed, so an unused
-					// one can be dropped entirely; an eager value must keep side effects.
+					// Active unused eager reexport: keep side effects. Unused getters
+					// are inactive and already replaced with `0` above.
 					source.replace(
 						dep.range[0],
 						dep.range[1] - 1,
-						dep.getter
-							? "/* unused reexport */ 0"
-							: `/* unused reexport */ ${requireExpr}`
+						`/* unused reexport */ ${requireExpr}`
 					);
 					return;
 				}
@@ -514,5 +608,6 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 	}
 };
 
+CommonJsExportRequireDependency.idsSymbol = idsSymbol;
+
 module.exports = CommonJsExportRequireDependency;
-module.exports.idsSymbol = idsSymbol;