webpack 5.110.3 → 5.111.0

package/lib/dependencies/ImportMetaMainDependency.js

@@ -0,0 +1,104 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const ConstDependency = require("./ConstDependency");
+const NullDependency = require("./NullDependency");
+
+/** @import { ReplaceSource } from "webpack-sources" */
+/** @import Dependency, { UpdateHashContext } from "../Dependency" */
+/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import Hash from "../util/Hash" */
+
+/**
+ * `import.meta.main` asks whether the module is the entry, which needs the
+ * module argument scope hoisting removes. An inner concatenated module is
+ * never an entry module, so it answers with a separate constant expression.
+ */
+class ImportMetaMainDependency extends ConstDependency {
+	/**
+	 * Creates an instance of ImportMetaMainDependency.
+	 * @param {string} expression the expression a module outside a concatenation evaluates
+	 * @param {string} concatenatedExpression the expression an inner concatenated module evaluates
+	 * @param {Range} range the source range
+	 * @param {(string[] | null)=} runtimeRequirements runtime requirements of `expression`
+	 */
+	constructor(expression, concatenatedExpression, range, runtimeRequirements) {
+		super(expression, range, runtimeRequirements);
+		/** @type {string} */
+		this.concatenatedExpression = concatenatedExpression;
+	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		super.updateHash(hash, context);
+		hash.update(this.concatenatedExpression);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.concatenatedExpression);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.concatenatedExpression = context.read();
+		super.deserialize(context.rest);
+	}
+}
+
+makeSerializable(
+	ImportMetaMainDependency,
+	"webpack/lib/dependencies/ImportMetaMainDependency"
+);
+
+ImportMetaMainDependency.Template = class ImportMetaMainDependencyTemplate extends (
+	NullDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {ImportMetaMainDependency} */ (dependency);
+		const concatenated = templateContext.concatenationScope !== undefined;
+		if (!concatenated && dep.runtimeRequirements) {
+			for (const req of dep.runtimeRequirements) {
+				templateContext.runtimeRequirements.add(req);
+			}
+		}
+		const expression = concatenated
+			? dep.concatenatedExpression
+			: dep.expression;
+		const range = /** @type {Range} */ (dep.range);
+		source.replace(range[0], range[1] - 1, expression);
+	}
+};
+
+module.exports = ImportMetaMainDependency;

package/lib/dependencies/ImportMetaPlugin.js

@@ -27,6 +27,7 @@ const createHooksRegistry = require("../util/createHooksRegistry");
 const { propertyAccess } = require("../util/property");
 const BuildTimeConstDependency = require("./BuildTimeConstDependency");
 const ConstDependency = require("./ConstDependency");
+const ImportMetaMainDependency = require("./ImportMetaMainDependency");
 const ImportMetaResolveDependency = require("./ImportMetaResolveDependency");
 const ModuleInitFragmentDependency = require("./ModuleInitFragmentDependency");
 
@@ -154,17 +155,44 @@ const isImportMetaFieldEnabled = (importMeta, field) => {
 };
 
 /**
- * Renders the `import.meta.main` comparison and bails out of scope hoisting.
+ * Renders the `import.meta.main` comparison, which reads the module argument a
+ * scope-hoisted module does not have. A caller that can answer the expression
+ * statically for an inner module rules out only the concatenation root.
  * @param {Parser} parser the parser
+ * @param {boolean} staticWhenInner whether an inner concatenated module answers it without the comparison
  * @returns {string} the comparison expression
  */
-const renderImportMetaMain = (parser) => {
+const renderImportMetaMain = (parser, staticWhenInner) => {
 	const currentModule = parser.state.module;
-	/** @type {JavascriptModuleBuildInfo} */
-	(currentModule.buildInfo).moduleConcatenationBailout = IMPORT_META_MAIN;
+	const buildInfo =
+		/** @type {JavascriptModuleBuildInfo} */
+		(currentModule.buildInfo);
+	if (staticWhenInner) {
+		buildInfo.moduleConcatenationRootBailout = IMPORT_META_MAIN;
+	} else {
+		buildInfo.moduleConcatenationBailout = IMPORT_META_MAIN;
+	}
 	return `${RuntimeGlobals.moduleCache}[${RuntimeGlobals.entryModuleId}] === ${currentModule.moduleArgument}`;
 };
 
+const IMPORT_META_VAR = "__webpack_import_meta__";
+
+/**
+ * The name of the module's synthesized `import.meta` binding, stepped aside when
+ * the source already spells it. Re-bundling webpack output is the case that
+ * matters: the earlier binding would shadow this one and make it initialize
+ * itself.
+ * @param {Parser} parser the parser
+ * @returns {string} a name no declaration in this module takes
+ */
+const importMetaVarName = (parser) => {
+	const { source } = parser.state;
+	if (!source || !source.includes(IMPORT_META_VAR)) return IMPORT_META_VAR;
+	let index = 2;
+	while (source.includes(`__webpack_import_meta_${index}__`)) index++;
+	return `__webpack_import_meta_${index}__`;
+};
+
 /**
  * Checks whether the callee is the `import.meta.resolve` member.
  * @param {Expression | Super} callee call callee
@@ -261,6 +289,10 @@ class ImportMetaPlugin {
 					BuildTimeConstDependency,
 					new BuildTimeConstDependency.Template()
 				);
+				compilation.dependencyTemplates.set(
+					ImportMetaMainDependency,
+					new ImportMetaMainDependency.Template()
+				);
 
 				/**
 				 * Returns file url.
@@ -442,7 +474,7 @@ class ImportMetaPlugin {
 							const referencedPropertiesInDestructuring =
 								parser.destructuringAssignmentPropertiesFor(metaProperty);
 							if (!referencedPropertiesInDestructuring) {
-								const varName = "__webpack_import_meta__";
+								const varName = importMetaVarName(parser);
 								const knownProps = [];
 								if (isImportMetaFieldEnabled(importMeta, "url")) {
 									knownProps.push(`url: ${importMetaUrl()}`);
@@ -451,7 +483,9 @@ class ImportMetaPlugin {
 									knownProps.push(`webpack: ${importMetaWebpackVersion()}`);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "main")) {
-									knownProps.push(`main: ${renderImportMetaMain(parser)}`);
+									knownProps.push(
+										`main: ${renderImportMetaMain(parser, false)}`
+									);
 								}
 								if (isImportMetaFieldEnabled(importMeta, "env")) {
 									addDefinitionValueDependencies();
@@ -471,8 +505,10 @@ class ImportMetaPlugin {
 								const plainInitCode = `var ${varName} = {${knownProps.join(
 									", "
 								)}};\n`;
+								// Each module owns its `import.meta`: it copies the bundle's one
+								// and inherits from it, so later host writes stay visible.
 								const initCode = preserveUnknown(importMeta)
-									? `var ${varName} = Object.assign(import.meta, {${knownProps.join(
+									? `var ${varName} = Object.assign(Object.create(import.meta), import.meta, {${knownProps.join(
 											", "
 										)}});\n`
 									: plainInitCode;
@@ -556,7 +592,7 @@ class ImportMetaPlugin {
 										break;
 									case "main":
 										if (fieldEnabled) {
-											append(`main: ${renderImportMetaMain(parser)},`);
+											append(`main: ${renderImportMetaMain(parser, false)},`);
 											runtimeRequirements.push(
 												RuntimeGlobals.moduleCache,
 												RuntimeGlobals.entryModuleId,
@@ -740,13 +776,21 @@ class ImportMetaPlugin {
 					if (isImportMetaFieldEnabled(importMeta, "main")) {
 						parser.hooks.expression
 							.for(IMPORT_META_MAIN)
-							.tap(PLUGIN_NAME, (expr) =>
-								toConstantDependency(parser, renderImportMetaMain(parser), [
-									RuntimeGlobals.moduleCache,
-									RuntimeGlobals.entryModuleId,
-									RuntimeGlobals.module
-								])(expr)
-							);
+							.tap(PLUGIN_NAME, (expr) => {
+								const dep = new ImportMetaMainDependency(
+									renderImportMetaMain(parser, true),
+									"false",
+									/** @type {Range} */ (expr.range),
+									[
+										RuntimeGlobals.moduleCache,
+										RuntimeGlobals.entryModuleId,
+										RuntimeGlobals.module
+									]
+								);
+								dep.loc = parser.getLocation(expr);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
 						parser.hooks.typeof
 							.for(IMPORT_META_MAIN)
 							.tap(

package/lib/dependencies/SystemRuntimeModule.js

@@ -24,6 +24,15 @@ class SystemRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/dependencies/WorkerDependency.js

@@ -140,8 +140,7 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 			dep.options.publicPath,
 			chunk,
 			templateContext.module,
-			chunkGraph,
-			runtimeRequirements
+			chunkGraph
 		);
 
 		if (analyzableSpecifier !== null) {

package/lib/dependencies/WorkletDependency.js

@@ -144,8 +144,7 @@ WorkletDependency.Template = class WorkletDependencyTemplate extends (
 			dep.options.publicPath,
 			entryChunk,
 			module,
-			chunkGraph,
-			runtimeRequirements
+			chunkGraph
 		);
 		if (analyzableSpecifier !== null) {
 			source.replace(

package/lib/dll/DelegatedModule.js

@@ -242,6 +242,7 @@ class DelegatedModule extends Module {
 	updateHash(hash, context) {
 		hash.update(this.delegationType);
 		hash.update(JSON.stringify(this.request));
+		hash.update(JSON.stringify(this.delegateData));
 		super.updateHash(hash, context);
 	}
 
@@ -299,7 +300,23 @@ class DelegatedModule extends Module {
 		this.delegationType = m.delegationType;
 		this.userRequest = m.userRequest;
 		this.originalRequest = m.originalRequest;
-		this.delegateData = m.delegateData;
+		const next = m.delegateData;
+		// cleanupForCache clears delegateData; compare surviving build products instead.
+		if (this.buildMeta) {
+			const nextMeta = { ...next.buildMeta };
+			const exportsDependency = this.dependencies[1];
+			const builtExports =
+				exportsDependency instanceof StaticExportsDependency
+					? exportsDependency.exports
+					: undefined;
+			if (
+				JSON.stringify(this.buildMeta) !== JSON.stringify(nextMeta) ||
+				JSON.stringify(builtExports) !== JSON.stringify(next.exports || true)
+			) {
+				this.buildMeta = undefined;
+			}
+		}
+		this.delegateData = next;
 	}
 
 	/**

package/lib/dll/DllReferencePlugin.js

@@ -8,7 +8,7 @@
 const ExternalModuleFactoryPlugin = require("../ExternalModuleFactoryPlugin");
 const DelegatedSourceDependency = require("../dependencies/DelegatedSourceDependency");
 const WebpackError = require("../errors/WebpackError");
-const { makePathsRelative } = require("../util/identifier");
+const { fileUrlToPath, makePathsRelative } = require("../util/identifier");
 const parseJson = require("../util/parseJson");
 const DelegatedModuleFactoryPlugin = require("./DelegatedModuleFactoryPlugin");
 
@@ -72,12 +72,13 @@ class DllReferencePlugin {
 			if ("manifest" in this.options) {
 				const manifest = this.options.manifest;
 				if (typeof manifest === "string") {
+					const manifestPath = fileUrlToPath(manifest);
 					/** @type {InputFileSystem} */
-					(compiler.inputFileSystem).readFile(manifest, (err, result) => {
+					(compiler.inputFileSystem).readFile(manifestPath, (err, result) => {
 						if (err) return callback(err);
 						/** @type {CompilationDataItem} */
 						const data = {
-							path: manifest,
+							path: manifestPath,
 							data: undefined,
 							error: undefined
 						};
@@ -93,13 +94,13 @@ class DllReferencePlugin {
 						} catch (parseErr) {
 							// Store the error in the params so that it can
 							// be added as a compilation error later on.
-							const manifestPath = makePathsRelative(
+							const relativePath = makePathsRelative(
 								compiler.context,
-								manifest,
+								manifestPath,
 								compiler.root
 							);
 							data.error = new DllManifestError(
-								manifestPath,
+								relativePath,
 								/** @type {Error} */ (parseErr).message
 							);
 						}
@@ -153,7 +154,9 @@ class DllReferencePlugin {
 				source,
 				type: this.options.type,
 				scope: this.options.scope,
-				context: this.options.context || compiler.context,
+				context: this.options.context
+					? fileUrlToPath(this.options.context)
+					: compiler.context,
 				content:
 					/** @type {DllReferencePluginOptionsContent} */
 					(resolvedContent),
@@ -176,7 +179,7 @@ class DllReferencePlugin {
 							/** @type {DllManifestError} */ (data.error)
 						);
 					}
-					compilation.fileDependencies.add(manifest);
+					compilation.fileDependencies.add(fileUrlToPath(manifest));
 				}
 			}
 		});

package/lib/dll/LibManifestPlugin.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const EntryDependency = require("../dependencies/EntryDependency");
 const { someInIterable } = require("../util/IterableHelpers");
+const asyncLib = require("../util/async");
 const { compareModulesById } = require("../util/comparators");
 const { dirname, mkdirp } = require("../util/fs");
 

package/lib/errors/AnalyzableBailoutsWarning.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} BailoutDetails
+ * @property {string} reason what keeps the runtime form, as the code generation recorded it
+ * @property {string[]} modules the modules it was recorded on, as many as are printed
+ * @property {number} count how many modules it was recorded on in all
+ */
+
+class AnalyzableBailoutsWarning extends WebpackError {
+	/**
+	 * Creates an instance of AnalyzableBailoutsWarning.
+	 * @param {BailoutDetails[]} bailouts the reasons found, the most frequent first
+	 * @param {number} references how many module and reason pairs there are
+	 */
+	constructor(bailouts, references) {
+		const list = bailouts
+			.map((it) => {
+				const more = it.count - it.modules.length;
+				const names = `${it.modules.join(", ")}${more > 0 ? `, and ${more} more` : ""}`;
+				return `\n  ${it.reason}\n    ${names}`;
+			})
+			.join("");
+
+		super(
+			`analyzable ESM output: ${references} ${references === 1 ? "reference keeps" : "references keep"} the runtime form:${list}\nA bundler reading this output cannot follow such a reference without running webpack's runtime. Each reason names the setting that keeps it; changing that setting lets the reference be written as a literal import() or new URL().\nFor more info visit https://webpack.js.org/configuration/output/#outputmodule`
+		);
+
+		/** @type {string} */
+		this.name = "AnalyzableBailoutsWarning";
+	}
+}
+
+module.exports = AnalyzableBailoutsWarning;

package/lib/errors/DuplicateModulesWarning.js

@@ -12,6 +12,7 @@ const WebpackError = require("./WebpackError");
  * @typedef {object} DuplicateModuleDetails
  * @property {string} name
  * @property {number} chunks how many chunks carry a copy
+ * @property {string[]} entrypoints the entrypoints those chunks belong to, when more than one
  * @property {number} wasted bytes the extra copies cost
  */
 
@@ -23,18 +24,22 @@ class DuplicateModulesWarning extends WebpackError {
 	 */
 	constructor(modules, wasted) {
 		const list = modules
-			.map(
-				(module) =>
-					`\n  ${module.name} (in ${module.chunks} chunks, ${formatSize(
-						module.wasted
-					)} extra)`
-			)
+			.map((module) => {
+				// Which entrypoints pay for it is the actionable part, so it leads
+				// where the copies are spread across more than one.
+				const where =
+					module.entrypoints.length > 1
+						? `in ${module.entrypoints.join(", ")}, ${module.chunks} chunks`
+						: `in ${module.chunks} chunks`;
+
+				return `\n  ${module.name} (${where}, ${formatSize(module.wasted)} extra)`;
+			})
 			.join("");
 
 		super(
 			`duplicate modules: copies of the same module across chunks add ${formatSize(
 				wasted
-			)}:${list}\nA module reached from several chunks is emitted into each of them unless a shared chunk holds it. 'optimization.splitChunks' can pull it into one.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
+			)}:${list}\nA module reached from several chunks is emitted into each of them unless a shared chunk holds it. 'optimization.splitChunks' can pull it into one, with 'chunks: "all"' where the copies are in different entrypoints.\nFor more info visit https://webpack.js.org/plugins/split-chunks-plugin/`
 		);
 
 		/** @type {string} */

package/lib/errors/EmptyCopyPatternWarning.js

@@ -0,0 +1,26 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class EmptyCopyPatternWarning extends WebpackError {
+	/**
+	 * Creates an instance of EmptyCopyPatternWarning.
+	 * @param {string} from the `from` of the pattern as written in the configuration
+	 * @param {string} glob the glob `from` was resolved to
+	 */
+	constructor(from, glob) {
+		super(
+			`The '${from}' pattern of 'output.copy' copied no file.\nIt resolved to '${glob}', which matches nothing on disk — usually a typo, a path relative to the wrong directory, or a directory a previous build step was supposed to create.\nSilence it with 'ignoreWarnings' when the pattern is optional.`
+		);
+
+		/** @type {string} */
+		this.name = "EmptyCopyPatternWarning";
+	}
+}
+
+module.exports = EmptyCopyPatternWarning;

package/lib/errors/ExternalStarReexportError.js

@@ -0,0 +1,44 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/** @import ExternalModule from "../ExternalModule" */
+/** @import Module from "../Module" */
+
+/**
+ * Error raised when a `module` library reexports everything from an external
+ * whose request names a property path instead of a module.
+ */
+class ExternalStarReexportError extends WebpackError {
+	/**
+	 * Captures the external and the library entry reexporting from it.
+	 * @param {ExternalModule} externalModule the reexported external
+	 * @param {Module} module the library entry module
+	 */
+	constructor(externalModule, module) {
+		const request = /** @type {string[]} */ (
+			externalModule.getResolvedRequest()
+		);
+		super(
+			`Can't 'export * from ${JSON.stringify(
+				externalModule.userRequest
+			)}': the external is configured as ${JSON.stringify(
+				request
+			)}, which is a property of ${JSON.stringify(
+				request[0]
+			)} and has no module specifier to reexport. Reexport the names explicitly or configure the external without a property path.`
+		);
+
+		/** @type {string} */
+		this.name = "ExternalStarReexportError";
+		/** @type {Module} */
+		this.module = module;
+	}
+}
+
+module.exports = ExternalStarReexportError;

package/lib/errors/MissingSourceMapsWarning.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} MissingSourceMapDetails
+ * @property {string} name the module, by request
+ * @property {string[]} loaders the loaders that ran on it
+ */
+
+class MissingSourceMapsWarning extends WebpackError {
+	/**
+	 * Creates an instance of MissingSourceMapsWarning.
+	 * @param {MissingSourceMapDetails[]} modules the modules whose map was lost
+	 * @param {number} total how many such modules there are
+	 */
+	constructor(modules, total) {
+		const list = modules
+			.map((it) => `\n  ${it.name} (${it.loaders.join(", ")})`)
+			.join("");
+
+		super(
+			`missing source maps: ${total} ${total === 1 ? "module was" : "modules were"} transformed by a loader that returned no source map:${list}\nA loader that rewrites code without returning a map leaves webpack mapping positions to the loader's output as though it were the file on disk, so every line the map names below that point is likely to be wrong. Have the loader pass its map to 'this.callback(null, code, map)', or take the loader out of the chain for this build.\nFor more info visit https://webpack.js.org/api/loaders/#thiscallback`
+		);
+
+		/** @type {string} */
+		this.name = "MissingSourceMapsWarning";
+	}
+}
+
+module.exports = MissingSourceMapsWarning;

package/lib/errors/ModuleParseError.js

@@ -101,7 +101,8 @@ class ModuleParseError extends WebpackError {
 				}
 			}
 
-			loc = { start: err.loc };
+			// a plain copy: a parser's own position class must not reach the cache
+			loc = { start: { line: lineNumber, column: err.loc.column } };
 		} else if (err && err.stack) {
 			message += `\n${err.stack}`;
 		}

package/lib/errors/UnusedAssetsWarning.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} UnusedAssetDetails
+ * @property {string} name the module, by request
+ * @property {number} size the bytes its file adds to the output
+ */
+
+class UnusedAssetsWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedAssetsWarning.
+	 * @param {UnusedAssetDetails[]} assets the assets nothing reads
+	 * @param {number} total the bytes they add between them
+	 */
+	constructor(assets, total) {
+		const list = assets
+			.map((it) => `\n  ${it.name} (${it.size} bytes)`)
+			.join("");
+
+		super(
+			`unused assets: ${total} bytes are emitted for ${assets.length === 1 ? "an import whose binding" : "imports whose bindings"} nothing reads:${list}\nThe import brings the file into the output but its value is never used, so the bytes ship for nothing. Drop the import, or write it as 'import "./file"' with no binding where the file is wanted on disk regardless — 'experiments.futureDefaults' already leaves those alone and drops these.\nFor more info visit https://webpack.js.org/guides/asset-modules/`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedAssetsWarning";
+	}
+}
+
+module.exports = UnusedAssetsWarning;

package/lib/errors/UnusedFederationWarning.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+/**
+ * @typedef {object} UnusedFederationDetails
+ * @property {string} name the share key or remote name, as declared
+ * @property {"shared" | "remote"} kind which list declared it
+ */
+
+class UnusedFederationWarning extends WebpackError {
+	/**
+	 * Creates an instance of UnusedFederationWarning.
+	 * @param {UnusedFederationDetails[]} entries the entries nothing used
+	 */
+	constructor(entries) {
+		const list = entries
+			.map((entry) => `\n  ${entry.name} (${entry.kind})`)
+			.join("");
+
+		super(
+			`unused federation config: ${entries.length} ${entries.length === 1 ? "entry was" : "entries were"} declared but never used:${list}\nA 'shared' key nothing imports is not shared at all — each side keeps its own copy, which for a package holding state breaks at runtime rather than only costing bytes. A 'remotes' name nothing imports is dead configuration, or names a remote the code spells differently.\nFor more info visit https://webpack.js.org/concepts/module-federation/`
+		);
+
+		/** @type {string} */
+		this.name = "UnusedFederationWarning";
+	}
+}
+
+module.exports = UnusedFederationWarning;