webpack 5.14.0 → 5.18.0

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/hmr/LazyCompilationPlugin.js

@@ -0,0 +1,348 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { RawSource } = require("webpack-sources");
+const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
+const Dependency = require("../Dependency");
+const Module = require("../Module");
+const ModuleFactory = require("../ModuleFactory");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
+const { registerNotSerializable } = require("../util/serialization");
+
+/** @typedef {import("../../declarations/WebpackOptions")} WebpackOptions */
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
+/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
+/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("../ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("../RequestShortener")} RequestShortener */
+/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+
+const TYPES = new Set(["javascript"]);
+
+class LazyCompilationDependency extends Dependency {
+	constructor(originalModule) {
+		super();
+		this.originalModule = originalModule;
+	}
+
+	get category() {
+		return "esm";
+	}
+
+	get type() {
+		return "lazy import()";
+	}
+
+	/**
+	 * @returns {string | null} an identifier to merge equal requests
+	 */
+	getResourceIdentifier() {
+		return this.originalModule.identifier();
+	}
+}
+
+registerNotSerializable(LazyCompilationDependency);
+
+class LazyCompilationProxyModule extends Module {
+	constructor(context, originalModule, request, client, data, active) {
+		super("lazy-compilation-proxy", context, originalModule.layer);
+		this.originalModule = originalModule;
+		this.request = request;
+		this.client = client;
+		this.data = data;
+		this.active = active;
+	}
+
+	/**
+	 * @returns {string} a unique identifier of the module
+	 */
+	identifier() {
+		return `lazy-compilation-proxy|${this.originalModule.identifier()}`;
+	}
+
+	/**
+	 * @param {RequestShortener} requestShortener the request shortener
+	 * @returns {string} a user readable identifier of the module
+	 */
+	readableIdentifier(requestShortener) {
+		return `lazy-compilation-proxy ${this.originalModule.readableIdentifier(
+			requestShortener
+		)}`;
+	}
+
+	/**
+	 * Assuming this module is in the cache. Update the (cached) module with
+	 * the fresh module from the factory. Usually updates internal references
+	 * and properties.
+	 * @param {Module} module fresh module
+	 * @returns {void}
+	 */
+	updateCacheModule(module) {
+		super.updateCacheModule(module);
+		const m = /** @type {LazyCompilationProxyModule} */ (module);
+		this.active = m.active;
+	}
+
+	/**
+	 * @param {LibIdentOptions} options options
+	 * @returns {string | null} an identifier for library inclusion
+	 */
+	libIdent(options) {
+		return `${this.originalModule.libIdent(options)}!lazy-compilation-proxy`;
+	}
+
+	/**
+	 * @param {NeedBuildContext} context context info
+	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @returns {void}
+	 */
+	needBuild(context, callback) {
+		callback(null, !this.buildInfo || this.buildInfo.active !== this.active);
+	}
+
+	/**
+	 * @param {WebpackOptions} options webpack options
+	 * @param {Compilation} compilation the compilation
+	 * @param {ResolverWithOptions} resolver the resolver
+	 * @param {InputFileSystem} fs the file system
+	 * @param {function(WebpackError=): void} callback callback function
+	 * @returns {void}
+	 */
+	build(options, compilation, resolver, fs, callback) {
+		this.buildInfo = {
+			active: this.active
+		};
+		/** @type {BuildMeta} */
+		this.buildMeta = {};
+		this.clearDependenciesAndBlocks();
+		const dep = new CommonJsRequireDependency(this.client);
+		this.addDependency(dep);
+		if (this.active) {
+			const dep = new LazyCompilationDependency(this.originalModule);
+			const block = new AsyncDependenciesBlock({});
+			block.addDependency(dep);
+			this.addBlock(block);
+		}
+		callback();
+	}
+
+	/**
+	 * @returns {Set<string>} types available (do not mutate)
+	 */
+	getSourceTypes() {
+		return TYPES;
+	}
+
+	/**
+	 * @param {string=} type the source type for which the size should be estimated
+	 * @returns {number} the estimated size of the module (must be non-zero)
+	 */
+	size(type) {
+		return 200;
+	}
+
+	/**
+	 * @param {CodeGenerationContext} context context for code generation
+	 * @returns {CodeGenerationResult} result
+	 */
+	codeGeneration({ runtimeTemplate, chunkGraph, moduleGraph }) {
+		const sources = new Map();
+		const runtimeRequirements = new Set();
+		runtimeRequirements.add(RuntimeGlobals.module);
+		const clientDep = /** @type {CommonJsRequireDependency} */ (this
+			.dependencies[0]);
+		const clientModule = moduleGraph.getModule(clientDep);
+		const block = this.blocks[0];
+		const client = Template.asString([
+			`var client = ${runtimeTemplate.moduleExports({
+				module: clientModule,
+				chunkGraph,
+				request: clientDep.userRequest,
+				runtimeRequirements
+			})}`,
+			`var data = ${JSON.stringify(this.data)};`
+		]);
+		const keepActive = Template.asString([
+			`var dispose = client.keepAlive({ data, active: ${JSON.stringify(
+				!!block
+			)}, module, onError });`
+		]);
+		let source;
+		if (block) {
+			const dep = block.dependencies[0];
+			const module = moduleGraph.getModule(dep);
+			source = Template.asString([
+				client,
+				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
+					chunkGraph,
+					block,
+					module,
+					request: this.request,
+					strict: false, // TODO this should be inherited from the original module
+					message: "import()",
+					runtimeRequirements
+				})};`,
+				"if (module.hot) {",
+				Template.indent([
+					"module.hot.accept();",
+					`module.hot.accept(${JSON.stringify(
+						chunkGraph.getModuleId(module)
+					)}, function() { module.hot.invalidate(); });`,
+					"module.hot.dispose(function(data) { delete data.resolveSelf; dispose(data); });",
+					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);"
+				]),
+				"}",
+				"function onError() { /* ignore */ }",
+				keepActive
+			]);
+		} else {
+			source = Template.asString([
+				client,
+				"var resolveSelf, onError;",
+				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
+				"if (module.hot) {",
+				Template.indent([
+					"module.hot.accept();",
+					"if (module.hot.data && module.hot.data.resolveSelf) module.hot.data.resolveSelf(module.exports);",
+					"module.hot.dispose(function(data) { data.resolveSelf = resolveSelf; dispose(data); });"
+				]),
+				"}",
+				keepActive
+			]);
+		}
+		sources.set("javascript", new RawSource(source));
+		return {
+			sources,
+			runtimeRequirements
+		};
+	}
+
+	/**
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		hash.update(this.active ? "active" : "");
+		hash.update(JSON.stringify(this.data));
+	}
+}
+
+registerNotSerializable(LazyCompilationProxyModule);
+
+class LazyCompilationDependencyFactory extends ModuleFactory {
+	constructor(factory) {
+		super();
+		this._factory = factory;
+	}
+
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		const dependency = /** @type {LazyCompilationDependency} */ (data
+			.dependencies[0]);
+		callback(null, {
+			module: dependency.originalModule
+		});
+	}
+}
+
+class LazyCompilationPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {(function(Compiler, string, function(Error?, any?): void): void) | function(Compiler, string): Promise<any>} options.backend the backend
+	 * @param {string} options.client the client reference
+	 * @param {boolean} options.entries true, when entries are lazy compiled
+	 */
+	constructor({ backend, client, entries }) {
+		this.backend = backend;
+		this.client = client;
+		this.entries = entries;
+	}
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		let backend;
+		compiler.hooks.beforeCompile.tapAsync(
+			"LazyCompilationPlugin",
+			(params, callback) => {
+				if (backend !== undefined) return callback();
+				const promise = this.backend(compiler, this.client, (err, result) => {
+					if (err) return callback(err);
+					backend = result;
+					callback();
+				});
+				if (promise && promise.then) {
+					promise.then(b => {
+						backend = b;
+						callback();
+					}, callback);
+				}
+			}
+		);
+		compiler.hooks.thisCompilation.tap(
+			"LazyCompilationPlugin",
+			(compilation, { normalModuleFactory }) => {
+				normalModuleFactory.hooks.module.tap(
+					"LazyCompilationPlugin",
+					(originalModule, createData, resolveData) => {
+						if (
+							resolveData.dependencies.every(
+								dep =>
+									dep.type === "import()" ||
+									(this.entries && dep.type === "entry")
+							) &&
+							!/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client/.test(
+								resolveData.request
+							)
+						) {
+							const moduleInfo = backend.module(originalModule);
+							if (!moduleInfo) return;
+							const { client, data, active } = moduleInfo;
+
+							return new LazyCompilationProxyModule(
+								compiler.context,
+								originalModule,
+								resolveData.request,
+								client,
+								data,
+								active
+							);
+						}
+					}
+				);
+				compilation.dependencyFactories.set(
+					LazyCompilationDependency,
+					new LazyCompilationDependencyFactory()
+				);
+			}
+		);
+		compiler.hooks.shutdown.tapAsync("LazyCompilationPlugin", callback => {
+			backend.dispose(callback);
+		});
+	}
+}
+
+module.exports = LazyCompilationPlugin;

package/lib/hmr/lazyCompilationBackend.js

@@ -0,0 +1,86 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const http = require("http");
+
+/** @typedef {import("../Compiler")} Compiler */
+
+/**
+ * @param {Compiler} compiler compiler
+ * @param {string} client client reference
+ * @param {function(Error?, any?): void} callback callback
+ * @returns {void}
+ */
+module.exports = (compiler, client, callback) => {
+	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
+	const activeModules = new Map();
+	const prefix = "/lazy-compilation-using-";
+	const server = http.createServer((req, res) => {
+		const keys = req.url.slice(prefix.length).split("@");
+		req.socket.on("close", () => {
+			setTimeout(() => {
+				for (const key of keys) {
+					const oldValue = activeModules.get(key) || 0;
+					activeModules.set(key, oldValue - 1);
+					if (oldValue === 1) {
+						logger.log(
+							`${key} is no longer in use. Next compilation will skip this module.`
+						);
+					}
+				}
+			}, 120000);
+		});
+		req.socket.setNoDelay(true);
+		res.writeHead(200, {
+			"content-type": "text/event-stream",
+			"Access-Control-Allow-Origin": "*"
+		});
+		res.write("\n");
+		let moduleActivated = false;
+		for (const key of keys) {
+			const oldValue = activeModules.get(key) || 0;
+			activeModules.set(key, oldValue + 1);
+			if (oldValue === 0) {
+				logger.log(`${key} is now in use and will be compiled.`);
+				moduleActivated = true;
+			}
+		}
+		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
+	});
+	server.listen(err => {
+		if (err) return callback(err);
+		const addr = server.address();
+		if (typeof addr === "string") throw new Error("addr must not be a string");
+		const urlBase =
+			addr.address === "::" || addr.address === "0.0.0.0"
+				? `http://localhost:${addr.port}`
+				: addr.family === "IPv6"
+				? `http://[${addr.address}]:${addr.port}`
+				: `http://${addr.address}:${addr.port}`;
+		logger.log(
+			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
+		);
+		callback(null, {
+			dispose(callback) {
+				server.close(callback);
+			},
+			module(originalModule) {
+				const key = `${encodeURIComponent(
+					originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
+				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
+				const active = activeModules.get(key) > 0;
+				return {
+					client: `webpack/hot/lazy-compilation-${
+						compiler.options.externalsPresets.node ? "node" : "web"
+					}.js?${encodeURIComponent(urlBase + prefix)}`,
+					data: key,
+					active
+				};
+			}
+		});
+	});
+};

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/javascript/JavascriptParser.js

@@ -10,6 +10,7 @@ const { SyncBailHook, HookMap } = require("tapable");
 const vm = require("vm");
 const Parser = require("../Parser");
 const StackedMap = require("../util/StackedMap");
+const binarySearchBounds = require("../util/binarySearchBounds");
 const memoize = require("../util/memoize");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
@@ -2625,13 +2626,17 @@ class JavascriptParser extends Parser {
 	}
 
 	walkCallExpression(expression) {
+		const isSimpleFunction = fn => {
+			return fn.params.every(p => p.type === "Identifier");
+		};
 		if (
 			expression.callee.type === "MemberExpression" &&
 			expression.callee.object.type.endsWith("FunctionExpression") &&
 			!expression.callee.computed &&
 			(expression.callee.property.name === "call" ||
 				expression.callee.property.name === "bind") &&
-			expression.arguments.length > 0
+			expression.arguments.length > 0 &&
+			isSimpleFunction(expression.callee.object)
 		) {
 			// (function(…) { }.call/bind(?, …))
 			this._walkIIFE(
@@ -2639,7 +2644,10 @@ class JavascriptParser extends Parser {
 				expression.arguments.slice(1),
 				expression.arguments[0]
 			);
-		} else if (expression.callee.type.endsWith("FunctionExpression")) {
+		} else if (
+			expression.callee.type.endsWith("FunctionExpression") &&
+			isSimpleFunction(expression.callee)
+		) {
 			// (function(…) { }(…))
 			this._walkIIFE(expression.callee, expression.arguments, null);
 		} else {
@@ -3376,9 +3384,16 @@ class JavascriptParser extends Parser {
 	}
 
 	getComments(range) {
-		return this.comments.filter(
-			comment => comment.range[0] >= range[0] && comment.range[1] <= range[1]
-		);
+		const [rangeStart, rangeEnd] = range;
+		const compare = (comment, needle) => comment.range[0] - needle;
+		let idx = binarySearchBounds.ge(this.comments, rangeStart, compare);
+		let commentsInRange = [];
+		while (this.comments[idx] && this.comments[idx].range[1] <= rangeEnd) {
+			commentsInRange.push(this.comments[idx]);
+			idx++;
+		}
+
+		return commentsInRange;
 	}
 
 	/**

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");