webpack 5.12.3 → 5.16.0

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/MultiCompiler.js

@@ -226,6 +226,7 @@ module.exports = class MultiCompiler {
 				}
 			}
 		}
+		/** @type {string[]} */
 		const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
 		const stack = this.compilers.filter(c => !targetFound(c));
 		while (stack.length > 0) {
@@ -241,6 +242,7 @@ module.exports = class MultiCompiler {
 			}
 		}
 		if (edges.size > 0) {
+			/** @type {string[]} */
 			const lines = Array.from(edges)
 				.sort(sortEdges)
 				.map(edge => `${edge.source.name} -> ${edge.target.name}`);

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/WatchIgnorePlugin.js

@@ -10,10 +10,15 @@ const schema = require("../schemas/plugins/WatchIgnorePlugin.json");
 
 /** @typedef {import("../declarations/plugins/WatchIgnorePlugin").WatchIgnorePluginOptions} WatchIgnorePluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./util/fs").WatchFileSystem} WatchFileSystem */
 
 const IGNORE_TIME_ENTRY = "ignore";
 
 class IgnoringWatchFileSystem {
+	/**
+	 * @param {WatchFileSystem} wfs original file system
+	 * @param {(string|RegExp)[]} paths ignored paths
+	 */
 	constructor(wfs, paths) {
 		this.wfs = wfs;
 		this.paths = paths;
@@ -63,7 +68,7 @@ class IgnoringWatchFileSystem {
 			close: () => watcher.close(),
 			pause: () => watcher.pause(),
 			getContextTimeInfoEntries: () => {
-				const dirTimestamps = watcher.getContextInfoEntries();
+				const dirTimestamps = watcher.getContextTimeInfoEntries();
 				for (const path of ignoredDirs) {
 					dirTimestamps.set(path, IGNORE_TIME_ENTRY);
 				}

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/cache/PackFileCacheStrategy.js

@@ -1072,18 +1072,18 @@ class PackFileCacheStrategy {
 				return promise.then(() => {
 					if (reportProgress) reportProgress(0.8, "serialize pack");
 					this.logger.time(`store pack`);
+					const updatedBuildDependencies = new Set(this.buildDependencies);
+					for (const dep of newBuildDependencies) {
+						updatedBuildDependencies.add(dep);
+					}
 					const content = new PackContainer(
 						pack,
 						this.version,
 						this.buildSnapshot,
-						this.buildDependencies,
+						updatedBuildDependencies,
 						this.resolveResults,
 						this.resolveBuildDependenciesSnapshot
 					);
-					// You might think this breaks all access to the existing pack
-					// which are still referenced, but serializing the pack memorizes
-					// all data in the pack and makes it no longer need the backing file
-					// So it's safe to replace the pack file
 					return this.fileSerializer
 						.serialize(content, {
 							filename: `${this.cacheLocation}/index.pack`,

package/lib/dependencies/AMDDefineDependency.js

@@ -79,7 +79,7 @@ const DEFINITIONS = {
 	lof: {
 		definition: "var XXX, XXXfactory, XXXmodule;",
 		content:
-			"!(XXXfactory = (#), (typeof XXXfactory === 'function' ? (XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports) : XXX = XXXfactory))",
+			"!(XXXfactory = (#), (typeof XXXfactory === 'function' ? ((XXXmodule = { id: YYY, exports: {}, loaded: false }), (XXX = XXXfactory.call(XXXmodule.exports, __webpack_require__, XXXmodule.exports, XXXmodule)), (XXXmodule.loaded = true), XXX === undefined && (XXX = XXXmodule.exports)) : XXX = XXXfactory))",
 		requests: [RuntimeGlobals.require, RuntimeGlobals.module]
 	},
 	laf: {

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/ids/IdHelpers.js

@@ -77,9 +77,14 @@ const shortenLongString = (string, delimiter) => {
  * @returns {string} short module name
  */
 const getShortModuleName = (module, context, associatedObjectForCache) => {
-	return avoidNumber(
-		module.libIdent({ context, associatedObjectForCache }) || ""
-	);
+	const libIdent = module.libIdent({ context, associatedObjectForCache });
+	if (libIdent) return avoidNumber(libIdent);
+	const nameForCondition = module.nameForCondition();
+	if (nameForCondition)
+		return avoidNumber(
+			makePathsRelative(context, nameForCondition, associatedObjectForCache)
+		);
+	return "";
 };
 exports.getShortModuleName = getShortModuleName;
 

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,