@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

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");
 
@@ -92,11 +93,9 @@ const IMPORT_META_FIELDS = new Set([
 	"webpackHot"
 ]);
 
-// Single source of truth for `import.meta` accesses that only exist in ES modules
-// and therefore mark a module as ESM (consumed by HarmonyDetectionParserPlugin).
-// `dirname`/`filename` are resolved by NodeStuffPlugin, the rest here. The webpack
-// pragmas `import.meta.webpackHot`/`webpackContext` are intentionally excluded:
-// they are usable in CommonJS modules and must not force ESM.
+// The `import.meta` accesses that exist only in ES modules, and so mark one.
+// `dirname` and `filename` are resolved by NodeStuffPlugin. The webpack pragmas
+// are excluded: they work in CommonJS too and must not force ESM.
 const IMPORT_META_NAMES = [
 	IMPORT_META,
 	IMPORT_META_URL,
@@ -108,11 +107,11 @@ const IMPORT_META_NAMES = [
 	IMPORT_META_RESOLVE
 ];
 
-// Ordering contract for import.meta parser hooks across plugins: ESM detection
-// (HarmonyDetectionParserPlugin, non-bailing) must observe every access before
-// any bailing replacement; the merged replacements here must run before
-// DefinePlugin object defines (default stage 0) and its nested destructuring
-// handler (stage 100).
+// WHY: the ordering contract for the `import.meta` parser hooks across plugins.
+// ESM detection (HarmonyDetectionParserPlugin, non-bailing) must observe every
+// access before any bailing replacement, and the merged replacements here must
+// run before DefinePlugin's object defines (default stage 0) and its nested
+// destructuring handler (stage 100).
 const IMPORT_META_STAGE_ESM_DETECTION = -1000;
 const IMPORT_META_STAGE_REPLACEMENT = -100;
 
@@ -154,17 +153,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 +287,10 @@ class ImportMetaPlugin {
 					BuildTimeConstDependency,
 					new BuildTimeConstDependency.Template()
 				);
+				compilation.dependencyTemplates.set(
+					ImportMetaMainDependency,
+					new ImportMetaMainDependency.Template()
+				);
 
 				/**
 				 * Returns file url.
@@ -442,7 +472,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 +481,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 +503,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 +590,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 +774,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/ImportParserPlugin.js

@@ -45,7 +45,7 @@ const getCommentCompilationWarning = memoize(() =>
  * } from "../../declarations/WebpackOptions"
  */
 /** @import { RawChunkGroupOptions } from "../ChunkGroup" */
-/** @import { ContextMode } from "../ContextModule" */
+/** @import { ContextMode } from "../context/ContextModule" */
 /** @import { RawReferencedExports } from "../Dependency" */
 /** @import { BuildMeta } from "../Module" */
 /**

package/lib/dependencies/LoaderPlugin.js

@@ -21,7 +21,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * } from "../Compilation"
  */
 /** @import Compiler from "../Compiler" */
-/** @import { BuildInfo } from "../Module" */
+/** @import Module, { BuildInfo } from "../Module" */
 
 /**
  * Defines the import module callback callback.
@@ -39,6 +39,31 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * @property {string=} baseUri target base uri
  */
 
+/**
+ * @callback LoadModuleCallback
+ * @param {Error | null} err error object
+ * @param {(string | Buffer)=} source source of the loaded module
+ * @param {(object | null)=} sourceMap source map of the loaded module
+ * @param {Module=} module the loaded module
+ * @returns {void}
+ */
+
+/**
+ * `importModule` takes a callback or, given none, answers with a promise, and
+ * TypeScript reads an intersection of call signatures as an overload set
+ * @typedef {{ (request: string, options: ImportModuleOptions | undefined, callback: ImportModuleCallback): void } & { (request: string, options?: ImportModuleOptions): Promise<ExecuteModuleExports> }} ImportModuleMethod
+ */
+
+/**
+ * These properties are added by the LoaderPlugin
+ * @typedef {object} LoaderPluginLoaderContext
+ * @property {(request: string, callback: LoadModuleCallback) => void} loadModule Resolves the given request to a module, applies all configured loaders and calls
+ * back with the generated source, the sourceMap and the module instance (usually an
+ * instance of NormalModule). Use this function if you need to know the source code
+ * of another module to generate the result.
+ * @property {ImportModuleMethod} importModule
+ */
+
 const PLUGIN_NAME = "LoaderPlugin";
 
 class LoaderPlugin {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -7,7 +7,7 @@
 
 const RequireContextDependency = require("./RequireContextDependency");
 
-/** @import { ContextMode } from "../ContextModule" */
+/** @import { ContextMode } from "../context/ContextModule" */
 /** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "RequireContextDependencyParserPlugin";

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

@@ -9,7 +9,7 @@ const makeSerializable = require("../util/makeSerializable");
 const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsRequireCall = require("./ContextDependencyTemplateAsRequireCall");
 
-/** @import { ContextOptions } from "../ContextModule" */
+/** @import { ContextOptions } from "../context/ContextModule" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Range]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Range]>} ObjectSerializerContext */

package/lib/dependencies/URLDependency.js

@@ -263,11 +263,12 @@ URLDependency.Template = class URLDependencyTemplate extends (
 			return;
 		}
 
-		// For ESM module output, emit the analyzable `new URL("./asset", import.meta.url)`
-		// form (literal specifier, no runtime helpers) so other bundlers and webpack itself
-		// can statically follow the asset. `url: "relative"` keeps the runtime form.
-		// A prefetch/preload hint doesn't force it: the `<link>` is emitted separately at
-		// chunk startup (`StartupAssetHintRuntimeModule`), independent of the call site.
+		// WHY: ESM module output emits the analyzable
+		// `new URL("./asset", import.meta.url)` form — a literal specifier, no runtime
+		// helpers — so other bundlers and webpack itself can statically follow the
+		// asset, while `url: "relative"` keeps the runtime form. A prefetch or preload
+		// hint does not force it: the `<link>` is emitted separately at chunk startup
+		// (`StartupAssetHintRuntimeModule`), independent of the call site.
 		if (
 			!dep.relative &&
 			runtimeTemplate.supportsAnalyzable(

package/lib/dependencies/WorkerAndWorkletPlugin.js

@@ -86,10 +86,9 @@ const WORKER_DEFAULT_SYNTAX = [
 	"Worker from worker_threads"
 ];
 
-// Worklets are always module scripts loaded through `addModule` and — unlike Web
-// Workers — cannot load additional chunks at runtime (no `importScripts`, no
-// dynamic `import()`). The WorkletDependency wraps the call so every chunk is
-// pre-added via `addModule` from the calling scope (see WorkletDependency).
+// A worklet is always a module script loaded through `addModule`, and unlike a
+// Web Worker cannot load further chunks at runtime, so WorkletDependency wraps
+// the call and pre-adds every chunk from the calling scope.
 const WORKLET_DEFAULT_SYNTAX = [
 	"*context.audioWorklet.addModule()",
 	"*audioWorklet.addModule()",
@@ -406,10 +405,9 @@ class WorkerAndWorkletPlugin {
 										)
 									);
 								} else {
-									// `webpackEntryOptions` is user input from a magic
-									// comment, so copy only safe own keys to avoid
-									// prototype pollution via `__proto__`/`constructor`/
-									// `prototype`.
+									// `webpackEntryOptions` is user input from a magic comment, so
+									// only safe own keys are copied, against prototype pollution
+									// through `__proto__` or `constructor`.
 									const userEntryOptions = importOptions.webpackEntryOptions;
 									for (const key of Object.keys(userEntryOptions)) {
 										if (
@@ -502,11 +500,9 @@ class WorkerAndWorkletPlugin {
 
 						/** @type {ResourceHint | undefined} */
 						let resourceHint;
-						// Resource-hint comments belong to the asset expression — read
-						// them from the inner `new URL(...)` range only, never from
-						// elsewhere inside `new Worker(...)`. When `arg1` is bare
-						// `import.meta.url` there is no `new URL` and no place for
-						// the comments to go, so resource hints are skipped.
+						// Resource-hint comments belong to the asset expression, so they are
+						// read from the inner `new URL(...)` range alone. A bare
+						// `import.meta.url` has none, so its hints are skipped.
 						if (arg1.type === "NewExpression") {
 							const { options: urlImportOptions } = parser.parseCommentOptions(
 								/** @type {Range} */ (arg1.range)
@@ -652,10 +648,9 @@ class WorkerAndWorkletPlugin {
 							name: entryOptions.name,
 							circular: false,
 							entryOptions: {
-								// A module worklet links its split chunks via native `import`
-								// (resolved by `addModule`), so it keeps the module chunk
-								// loading. A script worklet can't load chunks at runtime, so its
-								// chunks use import-scripts and are pre-added from the calling scope.
+								// A module worklet links its split chunks through native `import`
+								// and keeps module chunk loading. A script worklet loads none at
+								// runtime, so its chunks are pre-added from the calling scope.
 								chunkLoading: this._module
 									? this._chunkLoading
 									: "import-scripts",
@@ -800,10 +795,9 @@ class WorkerAndWorkletPlugin {
 						);
 					}
 
-					// Worklet parsing is opt-in: unset falls back to the `futureDefaults`
-					// default, `false` disables it. It is not defaulted in
-					// `config/defaults.js` because that would splice into the `"..."`
-					// merge sentinel of a user-provided list.
+					// Worklet parsing is opt-in: unset falls back to `futureDefaults` and
+					// `false` disables it. Not defaulted in `config/defaults.js`, which
+					// would splice into a user list's `"..."` sentinel.
 					const workletOption =
 						parserOptions.worklet === undefined
 							? this._workletDefault

package/lib/dependencies/WorkerDependency.js

@@ -131,17 +131,17 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 		);
 		const chunk = entrypoint.getEntrypointChunk();
 
-		// For ESM module output emit the analyzable `new URL("./worker.<name>.js",
-		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
-		// and webpack itself can statically follow the worker. A resource hint doesn't
-		// block it: the `<link>` is emitted at chunk startup instead of wrapping the href,
-		// which would turn the specifier into a non-analyzable expression.
+		// WHY: ESM module output emits the analyzable
+		// `new URL("./worker.<name>.js", import.meta.url)` form — a literal specifier,
+		// no runtime helpers — so other bundlers and webpack itself can statically
+		// follow the worker. A resource hint does not block it: the `<link>` is
+		// emitted at chunk startup instead of wrapping the href, which would turn the
+		// specifier into a non-analyzable expression.
 		const analyzableSpecifier = runtimeTemplate.getAnalyzableWorkerUrl(
 			dep.options.publicPath,
 			chunk,
 			templateContext.module,
-			chunkGraph,
-			runtimeRequirements
+			chunkGraph
 		);
 
 		if (analyzableSpecifier !== null) {

package/lib/dependencies/WorkletDependency.js

@@ -136,16 +136,14 @@ WorkletDependency.Template = class WorkletDependencyTemplate extends (
 		const runtimeChunkId =
 			runtimeChunk && runtimeChunk.id !== null ? runtimeChunk.id : null;
 
-		// For ESM module output emit the analyzable `new URL("./worklet.<name>.js",
-		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
-		// and webpack itself can statically follow the worklet. The worklet chunk links its
-		// splits via native `import`, so only the entry chunk is referenced.
+		// ESM output emits the analyzable `new URL("./worklet.<name>.js",
+		// import.meta.url)`, which another bundler can follow statically. Only the
+		// entry chunk is named, its splits being linked by native `import`.
 		const analyzableSpecifier = runtimeTemplate.getAnalyzableWorkerUrl(
 			dep.options.publicPath,
 			entryChunk,
 			module,
-			chunkGraph,
-			runtimeRequirements
+			chunkGraph
 		);
 		if (analyzableSpecifier !== null) {
 			source.replace(
@@ -197,11 +195,9 @@ WorkletDependency.Template = class WorkletDependencyTemplate extends (
 			return;
 		}
 
-		// A worklet can't load chunks at runtime, so every reachable chunk (initial
-		// splits and async `import()` targets alike) is pre-added via `addModule`
-		// from the calling scope. The runtime chunk is added last so it installs the
-		// chunks pushed before it and runs entry startup with every module present
-		// (see ImportScriptsChunkLoadingRuntimeModule).
+		// A worklet loads no chunks at runtime, so every reachable one is pre-added
+		// from the calling scope. The runtime chunk goes last, installing what came
+		// before it and running startup with every module present.
 		/** @type {(string | number)[]} */
 		const restChunkIds = [];
 		for (const chunk of referencedChunks) {

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;