webpack 5.107.2 → 5.108.0

package/lib/DefinePlugin.js

@@ -31,9 +31,11 @@ const createHash = require("./util/createHash");
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
+/** @typedef {import("./javascript/JavascriptParser").Members} Members */
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./logging/Logger").Logger} Logger */
 /** @typedef {import("./Compilation")} Compilation */
+/** @typedef {import("./NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
 
 /** @typedef {null | undefined | RegExp | EXPECTED_FUNCTION | string | number | boolean | bigint | undefined} CodeValuePrimitive */
 /** @typedef {RecursiveArrayOrRecord<CodeValuePrimitive | RuntimeValue>} CodeValue */
@@ -140,6 +142,17 @@ function getObjKeys(properties) {
 	return new Set([...properties].map((p) => p.id));
 }
 
+/**
+ * Whether a value is a nested definition (plain object/array) to recurse into.
+ * @param {CodeValue} code code value
+ * @returns {code is Definitions} true for a plain object or array
+ */
+const isObjectDefinition = (code) =>
+	Boolean(code) &&
+	typeof code === "object" &&
+	!(code instanceof RuntimeValue) &&
+	!(code instanceof RegExp);
+
 /** @typedef {Set<string> | null} ObjKeys */
 /** @typedef {boolean | undefined | null} AsiSafe */
 
@@ -439,7 +452,7 @@ class DefinePlugin {
 						/** @type {ValueCacheVersion} */
 						(compilation.valueCacheVersions.get(VALUE_DEP_MAIN));
 					parser.hooks.program.tap(PLUGIN_NAME, () => {
-						const buildInfo = /** @type {BuildInfo} */ (
+						const buildInfo = /** @type {NormalModuleBuildInfo} */ (
 							parser.state.module.buildInfo
 						);
 						if (!buildInfo.valueDependencies) {
@@ -454,9 +467,9 @@ class DefinePlugin {
 					 */
 					const addValueDependency = (key) => {
 						const buildInfo =
-							/** @type {BuildInfo} */
+							/** @type {NormalModuleBuildInfo} */
 							(parser.state.module.buildInfo);
-						/** @type {NonNullable<BuildInfo["valueDependencies"]>} */
+						/** @type {NonNullable<NormalModuleBuildInfo["valueDependencies"]>} */
 						(buildInfo.valueDependencies).set(
 							VALUE_DEP_PREFIX + key,
 							/** @type {ValueCacheVersion} */
@@ -487,12 +500,7 @@ class DefinePlugin {
 					const walkDefinitions = (definitions, prefix) => {
 						for (const key of Object.keys(definitions)) {
 							const code = definitions[key];
-							if (
-								code &&
-								typeof code === "object" &&
-								!(code instanceof RuntimeValue) &&
-								!(code instanceof RegExp)
-							) {
+							if (isObjectDefinition(code)) {
 								walkDefinitions(
 									/** @type {Definitions} */ (code),
 									`${prefix + key}.`
@@ -774,6 +782,77 @@ class DefinePlugin {
 							}
 							return toConstantDependency(parser, strCode)(expr);
 						});
+						// A property access not defined on the object resolves to `undefined`
+						// and the whole object is never inlined (issue #15559). Keyed by the
+						// chain root so dotted object keys (e.g. `a.b`) are also covered.
+						const chainParts = key.split(".");
+						// `import.meta` is one chain root (a MetaProperty), not two members.
+						const isMeta =
+							chainParts[0] === "import" && chainParts[1] === "meta";
+						const chainRoot = isMeta ? "import.meta" : chainParts[0];
+						const chainPrefix = chainParts.slice(isMeta ? 2 : 1);
+						/**
+						 * Whether a member chain reads a property that is not defined.
+						 * Collects every define key consulted so the caller can record a
+						 * value dependency on each (a sibling key like `OBJECT.SUB2` affects
+						 * the result even though `OBJECT` registered the handler).
+						 * `member in value` keeps inherited members (e.g. `toString`) defined.
+						 * @param {Members} members chain members (after the root)
+						 * @param {string[]} deps consulted define keys (mutated)
+						 * @returns {boolean} true when the access resolves to `undefined`
+						 */
+						const isUndefinedMemberAccess = (members, deps) => {
+							if (members.length <= chainPrefix.length) return false;
+							for (let i = 0; i < chainPrefix.length; i++) {
+								if (members[i] !== chainPrefix[i]) return false;
+							}
+							/** @type {CodeValue} */
+							let value = /** @type {CodeValue} */ (obj);
+							let path = key;
+							for (let i = chainPrefix.length; i < members.length; i++) {
+								// a leaf with members left is a real property access on a value
+								if (!isObjectDefinition(value)) return false;
+								const member = members[i];
+								const nextPath = `${path}.${member}`;
+								if (member in value) {
+									value = value[member];
+								} else if (
+									Object.prototype.hasOwnProperty.call(definitions, nextPath)
+								) {
+									// defined via a dotted sibling key, e.g. `OBJECT.SUB2`
+									deps.push(nextPath);
+									value = definitions[nextPath];
+								} else {
+									return true;
+								}
+								path = nextPath;
+							}
+							return false;
+						};
+						parser.hooks.expressionMemberChain
+							.for(chainRoot)
+							.tap(PLUGIN_NAME, (expr, members) => {
+								const deps = [key];
+								if (!isUndefinedMemberAccess(members, deps)) return;
+								for (const dep of deps) addValueDependency(dep);
+								return toConstantDependency(parser, "undefined")(expr);
+							});
+						// In a call, replace only the callee so the call itself is kept:
+						// `x.MISSING()` stays a (throwing) call and `x.MISSING?.()`
+						// short-circuits, with the object never inlined.
+						parser.hooks.callMemberChain
+							.for(chainRoot)
+							.tap(PLUGIN_NAME, (expr, members) => {
+								const deps = [key];
+								if (!isUndefinedMemberAccess(members, deps)) return;
+								for (const dep of deps) addValueDependency(dep);
+								toConstantDependency(
+									parser,
+									"undefined"
+								)(/** @type {Expression} */ (expr.callee));
+								parser.walkExpressions(expr.arguments);
+								return true;
+							});
 						parser.hooks.typeof
 							.for(key)
 							.tap(
@@ -821,12 +900,7 @@ class DefinePlugin {
 							warning.hideStack = true;
 							compilation.warnings.push(warning);
 						}
-						if (
-							code &&
-							typeof code === "object" &&
-							!(code instanceof RuntimeValue) &&
-							!(code instanceof RegExp)
-						) {
+						if (isObjectDefinition(code)) {
 							walkDefinitionsForValues(
 								/** @type {Definitions} */ (code),
 								`${prefix + key}.`

package/lib/Dependency.js

@@ -60,11 +60,13 @@ const memoize = require("./util/memoize");
  * @property {ExportInfoName} name the name of the export
  * @property {boolean=} canMangle can the export be renamed (defaults to true)
  * @property {boolean=} terminalBinding is the export a terminal binding that should be checked for export star conflicts
+ * @property {boolean=} isPure calling this export has no observable side effects
  * @property {(string | ExportSpec)[]=} exports nested exports
  * @property {ModuleGraphConnection=} from when reexported: from which module
  * @property {string[] | null=} export when reexported: from which export
  * @property {number=} priority when reexported: with which priority
  * @property {boolean=} hidden export is not visible, because another export blends over it
+ * @property {import("./optimize/InlineExports").InlinedValue=} inlined when set: the export binds to a small primitive constant eligible for inlining
  */
 
 /** @typedef {Set<string>} ExportsSpecExcludeExports */
@@ -79,6 +81,7 @@ const memoize = require("./util/memoize");
  * @property {number=} priority when reexported: with which priority
  * @property {boolean=} canMangle can the export be renamed (defaults to true)
  * @property {boolean=} terminalBinding are the exports terminal bindings that should be checked for export star conflicts
+ * @property {boolean=} isPure calling these exports has no observable side effects
  * @property {Module[]=} dependencies module on which the result depends on
  */
 
@@ -87,6 +90,7 @@ const memoize = require("./util/memoize");
  * @typedef {object} ReferencedExport
  * @property {string[]} name name of the referenced export
  * @property {boolean=} canMangle when false, referenced export can not be mangled, defaults to true
+ * @property {boolean=} canInline when false, the referenced export can not be substituted with an inlined literal at this site, defaults to true
  */
 
 /** @typedef {string[][]} RawReferencedExports */
@@ -94,6 +98,20 @@ const memoize = require("./util/memoize");
 
 /** @typedef {(moduleGraphConnection: ModuleGraphConnection, runtime: RuntimeSpec) => ConnectionState} GetConditionFn */
 
+/**
+ * Lazy barrel classification of a dependency within a side-effect-free module.
+ * `LAZY_UNTIL_LOCAL`: locally provided export name (`getLazyName`), requesting it requires no dependency.
+ * `LAZY_UNTIL_ID`: named re-export (`getLazyName`) deferred until the export name is requested.
+ * `LAZY_UNTIL_FALLBACK`: star re-export, deferred until an unknown name or all names are requested.
+ * `LAZY_UNTIL_REQUEST`: deferred together with other dependencies of the same request.
+ * @typedef {"local" | "id" | "*" | "@"} LazyUntil
+ */
+
+const LAZY_UNTIL_LOCAL = /** @type {"local"} */ ("local");
+const LAZY_UNTIL_ID = /** @type {"id"} */ ("id");
+const LAZY_UNTIL_FALLBACK = /** @type {"*"} */ ("*");
+const LAZY_UNTIL_REQUEST = /** @type {"@"} */ ("@");
+
 const TRANSITIVE = /** @type {symbol} */ (Symbol("transitive"));
 
 const getIgnoredModule = memoize(() => {
@@ -112,15 +130,16 @@ class Dependency {
 		this._parentDependenciesBlock = undefined;
 		/** @type {number} */
 		this._parentDependenciesBlockIndex = -1;
-		// TODO check if this can be moved into ModuleDependency
-		/** @type {boolean} */
-		this.weak = false;
-		// TODO check if this can be moved into ModuleDependency
+		// stays on base: also set on ContextDependency, which is not a ModuleDependency
 		/** @type {boolean | undefined} */
 		this.optional = false;
+		/** @type {number} */
 		this._locSL = 0;
+		/** @type {number} */
 		this._locSC = 0;
+		/** @type {number} */
 		this._locEL = 0;
+		/** @type {number} */
 		this._locEC = 0;
 		/** @type {undefined | number} */
 		this._locI = undefined;
@@ -189,7 +208,10 @@ class Dependency {
 		}
 		this._locI = "index" in loc ? loc.index : undefined;
 		this._locN = "name" in loc ? loc.name : undefined;
-		this._loc = loc;
+		// Don't retain the passed object; `get loc` rebuilds it from the numbers
+		// above on demand, so dependencies whose loc is never read hold 4 numbers
+		// instead of a SourceLocation + two Position objects.
+		this._loc = undefined;
 	}
 
 	/**
@@ -209,6 +231,42 @@ class Dependency {
 		this._loc = undefined;
 	}
 
+	/**
+	 * Updates loc from a source location plus an explicit index, without
+	 * materializing the `loc` object (keeps `get loc` lazy). Replaces the
+	 * `dep.loc = Object.create(loc); dep.loc.index = i` pattern, which both
+	 * allocated a copy and stored the index outside the serialized fields.
+	 * @param {DependencyLocation} loc source location (start/end/name read from it)
+	 * @param {number} index dependency index within the statement
+	 */
+	setLocWithIndex(loc, index) {
+		this.loc = loc;
+		this._locI = index;
+	}
+
+	/**
+	 * Compares two dependencies by source location for sorting a module's
+	 * `dependencies`, without materializing the `loc` objects (`get loc` caches
+	 * its result, so comparing through it would retain a location object on every
+	 * sorted dependency). These dependencies always carry a real source position,
+	 * so only start (line, column) and the within-statement index are compared; a
+	 * dependency without an index sorts after one that has an index at the same
+	 * position.
+	 * @param {Dependency} a first dependency
+	 * @param {Dependency} b second dependency
+	 * @returns {-1 | 0 | 1} compare result
+	 */
+	static compareLocations(a, b) {
+		if (a._locSL !== b._locSL) return a._locSL < b._locSL ? -1 : 1;
+		if (a._locSC !== b._locSC) return a._locSC < b._locSC ? -1 : 1;
+		const ai = a._locI;
+		const bi = b._locI;
+		if (ai === bi) return 0;
+		if (ai === undefined) return 1;
+		if (bi === undefined) return -1;
+		return ai < bi ? -1 : 1;
+	}
+
 	/**
 	 * Returns a request context.
 	 * @returns {string | undefined} a request context
@@ -233,6 +291,45 @@ class Dependency {
 		return TRANSITIVE;
 	}
 
+	/**
+	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
+	 * @returns {string | true | null} export name, true for all exports, null for none
+	 */
+	getForwardId() {
+		// unknown dependency types conservatively request all exports
+		return true;
+	}
+
+	/**
+	 * Returns how this dependency may be deferred when its parent module is side-effect-free (lazy barrel optimization).
+	 * @returns {LazyUntil | null} lazy classification, null when it must be processed eagerly
+	 */
+	getLazyUntil() {
+		return null;
+	}
+
+	/**
+	 * Returns the export name for a `LAZY_UNTIL_LOCAL`/`LAZY_UNTIL_ID` classification (lazy barrel optimization).
+	 * @returns {string | null} export name, null when not applicable
+	 */
+	getLazyName() {
+		return null;
+	}
+
+	/**
+	 * Whether the lazy barrel currently defers creating this dependency's target module (lazy barrel optimization).
+	 * @returns {boolean} true while deferred, so it must not be processed or rendered
+	 */
+	isLazy() {
+		return false;
+	}
+
+	/**
+	 * Sets whether the lazy barrel defers creating this dependency's target module (lazy barrel optimization).
+	 * @param {boolean} value true to defer, false to create it now
+	 */
+	setLazy(value) {}
+
 	/**
 	 * Returns the referenced module and export
 	 * @deprecated
@@ -338,7 +435,6 @@ class Dependency {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize({ write }) {
-		write(this.weak);
 		write(this.optional);
 		write(this._locSL);
 		write(this._locSC);
@@ -353,7 +449,6 @@ class Dependency {
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize({ read }) {
-		this.weak = read();
 		this.optional = read();
 		this._locSL = read();
 		this._locSC = read();
@@ -368,6 +463,11 @@ class Dependency {
 Dependency.NO_EXPORTS_REFERENCED = [];
 /** @type {RawReferencedExports} */
 Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
+// Like EXPORTS_OBJECT_REFERENCED, but the reference can be rendered as a
+// decoupled namespace object, so the module's exports stay mangleable.
+// Same shape as EXPORTS_OBJECT_REFERENCED; only distinguished by identity.
+/** @type {RawReferencedExports} */
+Dependency.EXPORTS_OBJECT_REFERENCED_MANGLEABLE = [[]];
 
 // TODO remove in webpack 6
 Object.defineProperty(Dependency.prototype, "module", {
@@ -430,5 +530,9 @@ Object.defineProperty(Dependency.prototype, "disconnect", {
 });
 
 Dependency.TRANSITIVE = TRANSITIVE;
+Dependency.LAZY_UNTIL_LOCAL = LAZY_UNTIL_LOCAL;
+Dependency.LAZY_UNTIL_ID = LAZY_UNTIL_ID;
+Dependency.LAZY_UNTIL_FALLBACK = LAZY_UNTIL_FALLBACK;
+Dependency.LAZY_UNTIL_REQUEST = LAZY_UNTIL_REQUEST;
 
 module.exports = Dependency;

package/lib/EntryOptionPlugin.js

@@ -5,14 +5,39 @@
 
 "use strict";
 
+const { SyncBailHook } = require("tapable");
+
 /** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 
+/**
+ * @typedef {object} EntryOptionPluginHooks
+ * @property {SyncBailHook<[string, string, EntryDescription], string | undefined>} entry transform an entry into a different request (e.g. wrap a non-HTML entry in a synthetic HTML module); return `undefined` to keep the default behavior
+ */
+
 const PLUGIN_NAME = "EntryOptionPlugin";
 
+/** @type {WeakMap<Compiler, EntryOptionPluginHooks>} */
+const hooksMap = new WeakMap();
+
 class EntryOptionPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler
+	 * @returns {EntryOptionPluginHooks} the hooks
+	 */
+	static getHooks(compiler) {
+		let hooks = hooksMap.get(compiler);
+		if (hooks === undefined) {
+			hooks = {
+				entry: new SyncBailHook(["context", "name", "entryDescription"])
+			};
+			hooksMap.set(compiler, hooks);
+		}
+		return hooks;
+	}
+
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance one is tapping into
@@ -50,8 +75,19 @@ class EntryOptionPlugin {
 				const descImport =
 					/** @type {Exclude<EntryDescription["import"], undefined>} */
 					(desc.import);
-				for (const entry of descImport) {
-					new EntryPlugin(context, entry, options).apply(compiler);
+				// A plugin (e.g. HtmlModulesPlugin) may rewrite the entry into a
+				// single synthetic request; otherwise each import becomes an entry.
+				const request = EntryOptionPlugin.getHooks(compiler).entry.call(
+					context,
+					name,
+					desc
+				);
+				if (request !== undefined) {
+					new EntryPlugin(context, request, options).apply(compiler);
+				} else {
+					for (const entry of descImport) {
+						new EntryPlugin(context, entry, options).apply(compiler);
+					}
 				}
 			}
 		}
@@ -77,6 +113,7 @@ class EntryOptionPlugin {
 			chunkLoading: desc.chunkLoading,
 			asyncChunks: desc.asyncChunks,
 			wasmLoading: desc.wasmLoading,
+			worker: desc.worker,
 			library: desc.library
 		};
 		if (desc.chunkLoading) {

package/lib/EntryPlugin.js

@@ -20,7 +20,9 @@ class EntryPlugin {
 	 * @param {EntryOptions | string=} options entry options (passing a string is deprecated)
 	 */
 	constructor(context, entry, options) {
+		/** @type {string} */
 		this.context = context;
+		/** @type {string} */
 		this.entry = entry;
 		this.options = options || "";
 	}