webpack 5.15.0 → 5.16.0

package/lib/ExportsInfo.js

@@ -457,7 +457,6 @@ class ExportsInfo {
 				case UsageState.NoInfo:
 					return null;
 				case UsageState.Unknown:
-					return true;
 				case UsageState.OnlyPropertiesUsed:
 				case UsageState.Used:
 					return true;

package/lib/IgnoreErrorModuleFactory.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const ModuleFactory = require("./ModuleFactory");
+
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+
+/**
+ * Ignores error when module is unresolved
+ */
+class IgnoreErrorModuleFactory extends ModuleFactory {
+	/**
+	 * @param {NormalModuleFactory} normalModuleFactory normalModuleFactory instance
+	 */
+	constructor(normalModuleFactory) {
+		super();
+
+		this.normalModuleFactory = normalModuleFactory;
+	}
+
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		this.normalModuleFactory.create(data, (err, result) => {
+			return callback(null, result);
+		});
+	}
+}
+
+module.exports = IgnoreErrorModuleFactory;

package/lib/NormalModuleFactory.js

@@ -147,10 +147,19 @@ const mergeGlobalOptions = (globalOptions, type, localOptions) => {
 };
 
 // TODO webpack 6 remove
-const deprecationChangedHookMessage = name =>
-	`NormalModuleFactory.${name} is no longer a waterfall hook, but a bailing hook instead. ` +
-	"Do not return the passed object, but modify it instead. " +
-	"Returning false will ignore the request and results in no module created.";
+const deprecationChangedHookMessage = (name, hook) => {
+	const names = hook.taps
+		.map(tapped => {
+			return tapped.name;
+		})
+		.join(", ");
+
+	return (
+		`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +
+		"Do not return the passed object, but modify it instead. " +
+		"Returning false will ignore the request and results in no module created."
+	);
+};
 
 const dependencyCache = new WeakMap();
 
@@ -270,7 +279,7 @@ class NormalModuleFactory extends ModuleFactory {
 
 					if (typeof result === "object")
 						throw new Error(
-							deprecationChangedHookMessage("resolve") +
+							deprecationChangedHookMessage("resolve", this.hooks.resolve) +
 								" Returning a Module object will result in this module used as result."
 						);
 
@@ -278,7 +287,12 @@ class NormalModuleFactory extends ModuleFactory {
 						if (err) return callback(err);
 
 						if (typeof result === "object")
-							throw new Error(deprecationChangedHookMessage("afterResolve"));
+							throw new Error(
+								deprecationChangedHookMessage(
+									"afterResolve",
+									this.hooks.afterResolve
+								)
+							);
 
 						// Ignored
 						if (result === false) return callback();
@@ -682,7 +696,12 @@ class NormalModuleFactory extends ModuleFactory {
 			}
 
 			if (typeof result === "object")
-				throw new Error(deprecationChangedHookMessage("beforeResolve"));
+				throw new Error(
+					deprecationChangedHookMessage(
+						"beforeResolve",
+						this.hooks.beforeResolve
+					)
+				);
 
 			this.hooks.factorize.callAsync(resolveData, (err, module) => {
 				if (err) {

package/lib/WebpackIsIncludedPlugin.js

@@ -0,0 +1,85 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const IgnoreErrorModuleFactory = require("./IgnoreErrorModuleFactory");
+const WebpackIsIncludedDependency = require("./dependencies/WebpackIsIncludedDependency");
+const {
+	toConstantDependency
+} = require("./javascript/JavascriptParserHelpers");
+
+/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+
+class WebpackIsIncludedPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"WebpackIsIncludedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WebpackIsIncludedDependency,
+					new IgnoreErrorModuleFactory(normalModuleFactory)
+				);
+				compilation.dependencyTemplates.set(
+					WebpackIsIncludedDependency,
+					new WebpackIsIncludedDependency.Template()
+				);
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					parser.hooks.call
+						.for("__webpack_is_included__")
+						.tap("WebpackIsIncludedPlugin", expr => {
+							if (
+								expr.type !== "CallExpression" ||
+								expr.arguments.length !== 1 ||
+								expr.arguments[0].type === "SpreadElement"
+							)
+								return;
+
+							const request = parser.evaluateExpression(expr.arguments[0]);
+
+							if (!request.isString()) return;
+
+							const dep = new WebpackIsIncludedDependency(
+								request.string,
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+							return true;
+						});
+					parser.hooks.typeof
+						.for("__webpack_is_included__")
+						.tap(
+							"WebpackIsIncludedPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("WebpackIsIncludedPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("WebpackIsIncludedPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("WebpackIsIncludedPlugin", handler);
+			}
+		);
+	}
+}
+
+module.exports = WebpackIsIncludedPlugin;

package/lib/WebpackOptionsApply.js

@@ -22,6 +22,7 @@ const APIPlugin = require("./APIPlugin");
 const CompatibilityPlugin = require("./CompatibilityPlugin");
 const ConstPlugin = require("./ConstPlugin");
 const ExportsInfoApiPlugin = require("./ExportsInfoApiPlugin");
+const WebpackIsIncludedPlugin = require("./WebpackIsIncludedPlugin");
 
 const TemplatedPathPlugin = require("./TemplatedPathPlugin");
 const UseStrictPlugin = require("./UseStrictPlugin");
@@ -272,6 +273,7 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		new APIPlugin().apply(compiler);
 		new ExportsInfoApiPlugin().apply(compiler);
+		new WebpackIsIncludedPlugin().apply(compiler);
 		new ConstPlugin().apply(compiler);
 		new UseStrictPlugin().apply(compiler);
 		new RequireIncludePlugin().apply(compiler);

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -6,7 +6,7 @@
 "use strict";
 
 const Dependency = require("../Dependency");
-const { UsageState } = require("../ExportsInfo");
+const { isDependencyUsedByExports } = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
 const propertyAccess = require("../util/propertyAccess");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
@@ -84,7 +84,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 	 */
 	getCondition(moduleGraph) {
 		return (connection, runtime) =>
-			this.checkUsedByExports(moduleGraph, runtime);
+			isDependencyUsedByExports(this, this.usedByExports, moduleGraph, runtime);
 	}
 
 	/**
@@ -95,21 +95,6 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return false;
 	}
 
-	checkUsedByExports(moduleGraph, runtime) {
-		if (this.usedByExports === false) return false;
-		if (this.usedByExports !== true && this.usedByExports !== undefined) {
-			const selfModule = moduleGraph.getParentModule(this);
-			const exportsInfo = moduleGraph.getExportsInfo(selfModule);
-			let used = false;
-			for (const exportName of this.usedByExports) {
-				if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
-					used = true;
-			}
-			if (!used) return false;
-		}
-		return true;
-	}
-
 	/**
 	 * Returns list of exports referenced by this dependency
 	 * @param {ModuleGraph} moduleGraph module graph

package/lib/dependencies/URLDependency.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { isDependencyUsedByExports } = require("../optimize/InnerGraph");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
@@ -15,16 +16,23 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class URLDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request
-	 * @param {[number, number]} range range
+	 * @param {[number, number]} range range of the arguments of new URL( |> ... <| )
+	 * @param {[number, number]} outerRange range of the full |> new URL(...) <|
 	 */
-	constructor(request, range) {
+	constructor(request, range, outerRange) {
 		super(request);
 		this.range = range;
+		this.outerRange = outerRange;
+		/** @type {Set<string> | boolean} */
+		this.usedByExports = undefined;
 	}
 
 	get type() {
@@ -34,6 +42,29 @@ class URLDependency extends ModuleDependency {
 	get category() {
 		return "url";
 	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return (connection, runtime) =>
+			isDependencyUsedByExports(this, this.usedByExports, moduleGraph, runtime);
+	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.outerRange);
+		write(this.usedByExports);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.outerRange = read();
+		this.usedByExports = read();
+		super.deserialize(context);
+	}
 }
 
 URLDependency.Template = class URLDependencyTemplate extends (
@@ -50,9 +81,20 @@ URLDependency.Template = class URLDependencyTemplate extends (
 			chunkGraph,
 			moduleGraph,
 			runtimeRequirements,
-			runtimeTemplate
+			runtimeTemplate,
+			runtime
 		} = templateContext;
 		const dep = /** @type {URLDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		// Skip rendering depending when dependency is conditional
+		if (connection && !connection.isTargetActive(runtime)) {
+			source.replace(
+				dep.outerRange[0],
+				dep.outerRange[1] - 1,
+				"/* unused asset import */ undefined"
+			);
+			return;
+		}
 
 		runtimeRequirements.add(RuntimeGlobals.baseURI);
 		runtimeRequirements.add(RuntimeGlobals.require);

package/lib/dependencies/URLPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { approve } = require("../javascript/JavascriptParserHelpers");
+const InnerGraph = require("../optimize/InnerGraph");
 const URLDependency = require("./URLDependency");
 
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
@@ -32,10 +33,12 @@ class URLPlugin {
 				 */
 				const parserCallback = (parser, parserOptions) => {
 					if (parserOptions.url === false) return;
-					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
-					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
-						const expr = /** @type {NewExpressionNode} */ (_expr);
 
+					/**
+					 * @param {NewExpressionNode} expr expression
+					 * @returns {undefined | string} request
+					 */
+					const getUrlRequest = expr => {
 						if (expr.arguments.length !== 2) return;
 
 						const [arg1, arg2] = expr.arguments;
@@ -59,16 +62,39 @@ class URLPlugin {
 
 						const request = parser.evaluateExpression(arg1).asString();
 
+						return request;
+					};
+
+					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
+					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
+						const expr = /** @type {NewExpressionNode} */ (_expr);
+
+						const request = getUrlRequest(expr);
+
 						if (!request) return;
 
-						const dep = new URLDependency(request, [
-							arg1.range[0],
-							arg2.range[1]
-						]);
+						const [arg1, arg2] = expr.arguments;
+						const dep = new URLDependency(
+							request,
+							[arg1.range[0], arg2.range[1]],
+							expr.range
+						);
 						dep.loc = expr.loc;
 						parser.state.module.addDependency(dep);
+						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 						return true;
 					});
+					parser.hooks.isPure.for("NewExpression").tap("URLPlugin", _expr => {
+						const expr = /** @type {NewExpressionNode} */ (_expr);
+						const { callee } = expr;
+						if (callee.type !== "Identifier") return;
+						const calleeInfo = parser.getFreeInfoFromVariable(callee.name);
+						if (!calleeInfo || calleeInfo.name !== "URL") return;
+
+						const request = getUrlRequest(expr);
+
+						if (request) return true;
+					});
 				};
 
 				normalModuleFactory.hooks.parser

package/lib/dependencies/WebpackIsIncludedDependency.js

@@ -0,0 +1,80 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const Template = require("../Template");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Dependency").ReferencedExport} ReferencedExport */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+class WebpackIsIncludedDependency extends ModuleDependency {
+	constructor(request, range) {
+		super(request);
+
+		this.weak = true;
+		this.range = range;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {(string[] | ReferencedExport)[]} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		// This doesn't use any export
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	get type() {
+		return "__webpack_is_included__";
+	}
+}
+
+makeSerializable(
+	WebpackIsIncludedDependency,
+	"webpack/lib/dependencies/WebpackIsIncludedDependency"
+);
+
+WebpackIsIncludedDependency.Template = class WebpackIsIncludedDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * @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, { runtimeTemplate, chunkGraph, moduleGraph }) {
+		const dep = /** @type {WebpackIsIncludedDependency} */ (dependency);
+		const connection = moduleGraph.getConnection(dep);
+		const included = connection
+			? chunkGraph.getNumberOfModuleChunks(connection.module) > 0
+			: false;
+		const comment = runtimeTemplate.outputOptions.pathinfo
+			? Template.toComment(
+					`__webpack_is_included__ ${runtimeTemplate.requestShortener.shorten(
+						dep.request
+					)}`
+			  )
+			: "";
+
+		source.replace(
+			dep.range[0],
+			dep.range[1] - 1,
+			`${comment}${JSON.stringify(included)}`
+		);
+	}
+};
+
+module.exports = WebpackIsIncludedDependency;

package/lib/javascript/JavascriptModulesPlugin.js

@@ -848,6 +848,7 @@ class JavascriptModulesPlugin {
 			buf.push("");
 		}
 
+		const maybeReturn = returnExportsFromRuntime ? "return " : "";
 		if (!runtimeRequirements.has(RuntimeGlobals.startupNoDefault)) {
 			if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
 				/** @type {string[]} */
@@ -933,7 +934,7 @@ class JavascriptModulesPlugin {
 					);
 					buf.push("");
 					startup.push("// run startup");
-					startup.push(`return ${RuntimeGlobals.startup}();`);
+					startup.push(`${maybeReturn}${RuntimeGlobals.startup}();`);
 				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
 					buf.push("// the startup function");
 					buf.push(
@@ -951,7 +952,7 @@ class JavascriptModulesPlugin {
 					startup.push("// startup");
 					startup.push(Template.asString(buf2));
 					afterStartup.push("// run runtime startup");
-					afterStartup.push(`return ${RuntimeGlobals.startup}();`);
+					afterStartup.push(`${maybeReturn}${RuntimeGlobals.startup}();`);
 				} else {
 					startup.push("// startup");
 					startup.push(Template.asString(buf2));
@@ -980,7 +981,7 @@ class JavascriptModulesPlugin {
 				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()}`
 			);
 			startup.push("// run startup");
-			startup.push(`return ${RuntimeGlobals.startup}();`);
+			startup.push(`${maybeReturn}${RuntimeGlobals.startup}();`);
 		}
 		return result;
 	}

package/lib/library/AssignLibraryPlugin.js

@@ -87,6 +87,7 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
  * @property {string[] | "global"} prefix name prefix
  * @property {string | false} declare declare name as variable
  * @property {"error"|"copy"|"assign"} unnamed behavior for unnamed library name
+ * @property {"copy"|"assign"=} named behavior for named library name
  */
 
 /**
@@ -94,6 +95,9 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
  * @property {string | string[]} name
  */
 
+const COMMON_LIBRARY_NAME_MESSAGE =
+	"Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.";
+
 /**
  * @typedef {AssignLibraryPluginParsed} T
  * @extends {AbstractLibraryPlugin<AssignLibraryPluginParsed>}
@@ -110,6 +114,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 		this.prefix = options.prefix;
 		this.declare = options.declare;
 		this.unnamed = options.unnamed;
+		this.named = options.named || "assign";
 	}
 
 	/**
@@ -120,11 +125,15 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 		const { name } = library;
 		if (this.unnamed === "error") {
 			if (typeof name !== "string" && !Array.isArray(name)) {
-				throw new Error("Library name must be a string or string array");
+				throw new Error(
+					`Library name must be a string or string array. ${COMMON_LIBRARY_NAME_MESSAGE}`
+				);
 			}
 		} else {
 			if (name && typeof name !== "string" && !Array.isArray(name)) {
-				throw new Error("Library name must be a string, string array or unset");
+				throw new Error(
+					`Library name must be a string, string array or unset. ${COMMON_LIBRARY_NAME_MESSAGE}`
+				);
 			}
 		}
 		return {
@@ -156,12 +165,12 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 				throw new Error(
 					`Library name base (${base}) must be a valid identifier when using a var declaring library type. Either use a valid identifier (e. g. ${Template.toIdentifier(
 						base
-					)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.`
+					)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${COMMON_LIBRARY_NAME_MESSAGE}`
 				);
 			}
 			result.add(`${this.declare} ${base};`);
 		}
-		if (!options.name && this.unnamed === "copy") {
+		if (options.name ? this.named === "copy" : this.unnamed === "copy") {
 			result.add(
 				`(function(e, a) { for(var i in a) e[i] = a[i]; if(a.__esModule) Object.defineProperty(e, "__esModule", { value: true }); }(${accessWithInit(
 					fullNameResolved,

package/lib/library/EnableLibraryPlugin.js

@@ -87,6 +87,18 @@ class EnableLibraryPlugin {
 					}).apply(compiler);
 					break;
 				}
+				case "assign-properties": {
+					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
+					const AssignLibraryPlugin = require("./AssignLibraryPlugin");
+					new AssignLibraryPlugin({
+						type,
+						prefix: [],
+						declare: false,
+						unnamed: "error",
+						named: "copy"
+					}).apply(compiler);
+					break;
+				}
 				case "assign": {
 					//@ts-expect-error https://github.com/microsoft/TypeScript/issues/41697
 					const AssignLibraryPlugin = require("./AssignLibraryPlugin");

package/lib/optimize/InnerGraph.js

@@ -5,9 +5,14 @@
 
 "use strict";
 
+const { UsageState } = require("../ExportsInfo");
+
 /** @typedef {import("estree").Node} AnyNode */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /** @typedef {Map<TopLevelSymbol, Set<string | TopLevelSymbol> | true>} InnerGraph */
 /** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
@@ -254,6 +259,33 @@ exports.tagTopLevelSymbol = (parser, name) => {
 	return fn;
 };
 
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {boolean} false, when unused. Otherwise true
+ */
+exports.isDependencyUsedByExports = (
+	dependency,
+	usedByExports,
+	moduleGraph,
+	runtime
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule = moduleGraph.getParentModule(dependency);
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		let used = false;
+		for (const exportName of usedByExports) {
+			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
+				used = true;
+		}
+		if (!used) return false;
+	}
+	return true;
+};
+
 class TopLevelSymbol {
 	/**
 	 * @param {string} name name of the variable

package/lib/optimize/SplitChunksPlugin.js

@@ -1298,7 +1298,10 @@ module.exports = class SplitChunksPlugin {
 								) {
 									continue;
 								}
-								if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+								if (
+									item.chunks.size > 1 &&
+									chunkGraph.getNumberOfEntryModules(chunk) > 0
+								) {
 									continue;
 								}
 								for (const module of item.modules) {

package/lib/sharing/ProvideSharedModule.js

@@ -143,7 +143,7 @@ class ProvideSharedModule extends Module {
 						request: this._request,
 						runtimeRequirements
 				  })
-		});`;
+		}${this._eager ? ", 1" : ""});`;
 		const sources = new Map();
 		const data = new Map();
 		data.set("share-init", [

package/lib/sharing/ShareRuntimeModule.js

@@ -83,11 +83,11 @@ class ShareRuntimeModule extends RuntimeModule {
 					)};`,
 					`var uniqueName = ${JSON.stringify(uniqueName || undefined)};`,
 					`var register = ${runtimeTemplate.basicFunction(
-						"name, version, factory",
+						"name, version, factory, eager",
 						[
 							"var versions = scope[name] = scope[name] || {};",
 							"var activeVersion = versions[version];",
-							"if(!activeVersion || !activeVersion.loaded && uniqueName > activeVersion.from) versions[version] = { get: factory, from: uniqueName };"
+							"if(!activeVersion || (!activeVersion.loaded && (!eager != !activeVersion.eager ? eager : uniqueName > activeVersion.from))) versions[version] = { get: factory, from: uniqueName, eager: !!eager };"
 						]
 					)};`,
 					`var initExternal = ${runtimeTemplate.basicFunction("id", [

package/lib/util/internalSerializables.js

@@ -150,6 +150,8 @@ module.exports = {
 		require("../dependencies/WebAssemblyExportImportedDependency"),
 	"dependencies/WebAssemblyImportDependency": () =>
 		require("../dependencies/WebAssemblyImportDependency"),
+	"dependencies/WebpackIsIncludedDependency": () =>
+		require("../dependencies/WebpackIsIncludedDependency"),
 	"dependencies/WorkerDependency": () =>
 		require("../dependencies/WorkerDependency"),
 	"optimize/ConcatenatedModule": () =>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.15.0",
+  "version": "5.16.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",

package/schemas/WebpackOptions.json

@@ -1252,13 +1252,14 @@
       "required": ["type"]
     },
     "LibraryType": {
-      "description": "Type of library (types included by default are 'var', 'module', 'assign', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).",
+      "description": "Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).",
       "anyOf": [
         {
           "enum": [
             "var",
             "module",
             "assign",
+            "assign-properties",
             "this",
             "window",
             "self",

package/schemas/plugins/container/ContainerPlugin.json

@@ -201,13 +201,14 @@
       "required": ["type"]
     },
     "LibraryType": {
-      "description": "Type of library (types included by default are 'var', 'module', 'assign', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).",
+      "description": "Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).",
       "anyOf": [
         {
           "enum": [
             "var",
             "module",
             "assign",
+            "assign-properties",
             "this",
             "window",
             "self",

package/schemas/plugins/container/ModuleFederationPlugin.json

@@ -225,13 +225,14 @@
       "required": ["type"]
     },
     "LibraryType": {
-      "description": "Type of library (types included by default are 'var', 'module', 'assign', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).",
+      "description": "Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).",
       "anyOf": [
         {
           "enum": [
             "var",
             "module",
             "assign",
+            "assign-properties",
             "this",
             "window",
             "self",

package/types.d.ts

@@ -4978,7 +4978,7 @@ declare interface LibraryOptions {
 	name?: string | string[] | LibraryCustomUmdObject;
 
 	/**
-	 * Type of library (types included by default are 'var', 'module', 'assign', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).
+	 * Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).
 	 */
 	type: string;
 
@@ -6851,7 +6851,7 @@ declare interface Output {
 	libraryExport?: string | string[];
 
 	/**
-	 * Type of library (types included by default are 'var', 'module', 'assign', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).
+	 * Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).
 	 */
 	libraryTarget?: string;