@depup/webpack 5.109.2-depup.0 → 5.110.1-depup.0

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const glob2regexp = require("watchpack").util.globToRegExp;
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
@@ -17,26 +16,41 @@ const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const formatLocation = require("../util/formatLocation");
+const { dirname, join, readJson, relative } = require("../util/fs");
+const { getGlobToRegExpSource } = require("../util/globUtils");
+const {
+	NODE_MODULES_REGEXP,
+	WINDOWS_PATH_SEPARATOR_REGEXP,
+	relativePathToRequest
+} = require("../util/identifier");
 const { CompilerHintNotationRegExp } = require("../util/magicComment");
 
-/** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
-/** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
-/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
-/** @typedef {import("estree").Statement} Statement */
-/** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
-/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
-/** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
-/** @typedef {import("../ExportsInfo").TargetItemWithConnection} TargetItemWithConnection */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/**
+ * @import {
+ * 	MaybeNamedClassDeclaration,
+ * 	MaybeNamedFunctionDeclaration,
+ * 	ModuleDeclaration,
+ * 	Statement,
+ * 	CallExpression
+ * } from "estree"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import Module, { BuildMeta } from "../Module" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "../javascript/JavascriptModule"
+ */
+/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
+/** @import { ExportInfo, TargetItemWithConnection } from "../ExportsInfo" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
+/** @import { InputFileSystem } from "../util/fs" */
+/** @import { CreateData, ResolveData } from "../NormalModuleFactory" */
+/**
+ * @import {
+ * 	JavascriptParserOptions
+ * } from "../../declarations/WebpackOptions"
+ */
 
 /**
  * Defines the export in module type used by this module.
@@ -46,10 +60,35 @@ const { CompilerHintNotationRegExp } = require("../util/magicComment");
  * @property {boolean} checked if the export is conditional
  */
 
+/** @typedef {NonNullable<CreateData["resourceResolveData"]>} ResourceResolveData */
+
 /** @typedef {string | boolean | string[] | undefined} SideEffectsFlagValue */
 
 /** @typedef {Map<string, RegExp>} CacheItem */
 
+/**
+ * @typedef {object} ResolvedSideEffectsFlag
+ * @property {SideEffectsFlagValue} sideEffects package.json sideEffects value
+ * @property {string} relativePath path relative to the owning package root
+ */
+
+/**
+ * @typedef {object} OwningSideEffectsFlag
+ * @property {SideEffectsFlagValue} sideEffects package.json sideEffects value
+ * @property {string} packageRoot directory of the declaring package.json
+ */
+
+/**
+ * A finished ancestor walk, kept per descriptionFileRoot. The package.json
+ * paths it consulted are replayed as dependencies for every module reusing it.
+ * @typedef {object} OwningSideEffectsFlagWalk
+ * @property {OwningSideEffectsFlag | null} owning declaring package, `null` when the walk found none
+ * @property {string[]} read package.json files the walk read
+ * @property {string[]} missing package.json files the walk did not find
+ */
+
+/** @typedef {Map<string, OwningSideEffectsFlagWalk>} OwningSideEffectsFlagCache */
+
 /**
  * Whether a resolved re-export target is reached through an `import defer` edge.
  * Such edges must not be collapsed by the side-effect-free barrel optimization:
@@ -67,6 +106,21 @@ const isDeferredTargetConnection = (connection) =>
 /** @type {WeakMap<Compiler, CacheItem>} */
 const globToRegexpCache = new WeakMap();
 
+/** @type {WeakMap<Compiler, OwningSideEffectsFlagCache>} */
+const owningSideEffectsFlagCache = new WeakMap();
+
+/** @type {WeakMap<Partial<CreateData>, ResolvedSideEffectsFlag>} */
+const resolvedSideEffectsFlags = new WeakMap();
+
+/**
+ * Whether a failed ancestor package.json read means nothing is there, as
+ * opposed to something being there that cannot be used.
+ * @param {NodeJS.ErrnoException | SyntaxError | Error} err error from readJson
+ * @returns {boolean} true when no file was found at that path
+ */
+const isMissingPackageJsonError = (err) =>
+	"code" in err && err.code === "ENOENT";
+
 /**
  * Returns a regular expression.
  * @param {string} glob the pattern
@@ -79,7 +133,7 @@ const globToRegexp = (glob, cache) => {
 	if (!glob.includes("/")) {
 		glob = `**/${glob}`;
 	}
-	const regexpSource = glob2regexp(glob);
+	const regexpSource = getGlobToRegExpSource()(glob);
 	const regexp = new RegExp(`^(\\./)?${regexpSource}$`);
 	cache.set(glob, regexp);
 	return regexp;
@@ -110,6 +164,144 @@ const notSideEffectsTag = Symbol("NoSideEffects");
 /** @type {(target: { module: Module }) => boolean} */
 const RETURNS_FALSE = () => false;
 
+/**
+ * Resolve sideEffects from the package that declares it, inheriting past a nested
+ * package.json that declares none. Globs are rebased on the declaring package root,
+ * and each package.json the walk consults becomes a dependency of the resolve.
+ * @param {InputFileSystem} fs file system
+ * @param {ResolveData} resolveData resolve data
+ * @param {string} descriptionFileRoot root directory of the nearest description file
+ * @param {OwningSideEffectsFlagCache} owningCache walk cache keyed by descriptionFileRoot
+ * @param {(result?: ResolvedSideEffectsFlag) => void} callback callback
+ * @returns {void}
+ */
+const resolveSideEffectsFlag = (
+	fs,
+	resolveData,
+	descriptionFileRoot,
+	owningCache,
+	callback
+) => {
+	const resolveInfo = /** @type {ResourceResolveData} */ (
+		resolveData.createData.resourceResolveData
+	);
+	const descriptionFileData =
+		/** @type {NonNullable<ResourceResolveData["descriptionFileData"]>} */ (
+			resolveInfo.descriptionFileData
+		);
+	const relativePath = /** @type {string} */ (resolveInfo.relativePath);
+	if (descriptionFileData.sideEffects !== undefined) {
+		return callback({
+			sideEffects: /** @type {SideEffectsFlagValue} */ (
+				descriptionFileData.sideEffects
+			),
+			relativePath
+		});
+	}
+	// Named package with no sideEffects: do not inherit from outside.
+	if (descriptionFileData.name !== undefined) {
+		return callback();
+	}
+	// Only inherit for a file living under node_modules; app-local nests keep shadowing.
+	// Read the resolved path so a symlinked package flags all of its files alike.
+	if (
+		typeof resolveInfo.path !== "string" ||
+		!NODE_MODULES_REGEXP.test(resolveInfo.path)
+	) {
+		return callback();
+	}
+
+	// stays in descriptionFileRoot's space, which is the space packageRoot is found in
+	const resourcePath = join(fs, descriptionFileRoot, relativePath);
+
+	/**
+	 * @param {OwningSideEffectsFlagWalk} walk finished walk
+	 * @returns {void}
+	 */
+	const finishFromWalk = (walk) => {
+		for (const file of walk.read) resolveData.fileDependencies.add(file);
+		for (const file of walk.missing) resolveData.missingDependencies.add(file);
+		const owning = walk.owning;
+		if (owning === null) return callback();
+		const ancestorRelative = relative(
+			fs,
+			owning.packageRoot,
+			resourcePath
+		).replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/");
+		return callback({
+			sideEffects: owning.sideEffects,
+			relativePath: relativePathToRequest(ancestorRelative)
+		});
+	};
+
+	const cached = owningCache.get(descriptionFileRoot);
+	if (cached !== undefined) {
+		return finishFromWalk(cached);
+	}
+
+	/** @type {string[]} */
+	const read = [];
+	/** @type {string[]} */
+	const missing = [];
+
+	/**
+	 * @param {OwningSideEffectsFlag | null} owning declaring package or null
+	 * @returns {void}
+	 */
+	const done = (owning) => {
+		/** @type {OwningSideEffectsFlagWalk} */
+		const walk = { owning, read, missing };
+		owningCache.set(descriptionFileRoot, walk);
+		return finishFromWalk(walk);
+	};
+
+	let dir = dirname(fs, descriptionFileRoot);
+
+	const next = () => {
+		const parent = dirname(fs, dir);
+		if (!parent || parent === dir) return done(null);
+		const baseName = relative(fs, parent, dir).replace(
+			WINDOWS_PATH_SEPARATOR_REGEXP,
+			"/"
+		);
+		// Do not inherit an application's sideEffects across an install boundary.
+		if (baseName === "node_modules") return done(null);
+
+		const packageJsonPath = join(fs, dir, "package.json");
+
+		readJson(fs, packageJsonPath, (err, data) => {
+			if (err) {
+				if (!isMissingPackageJsonError(err)) {
+					// it is there but unreadable, so what it declares is unknown:
+					// decline rather than let an outer flag speak for it
+					read.push(packageJsonPath);
+					return done(null);
+				}
+				missing.push(packageJsonPath);
+				dir = parent;
+				return next();
+			}
+			read.push(packageJsonPath);
+			if (!data || typeof data !== "object" || Array.isArray(data)) {
+				dir = parent;
+				return next();
+			}
+			if (data.sideEffects !== undefined) {
+				return done({
+					sideEffects: /** @type {SideEffectsFlagValue} */ (data.sideEffects),
+					packageRoot: dir
+				});
+			}
+			// An unnamed manifest deeper in the package keeps the walk going; a named one
+			// is a package of its own, and its silence is its answer.
+			if (data.name !== undefined) return done(null);
+			dir = parent;
+			next();
+		});
+	};
+	next();
+};
+
 /**
  * Detects if the module is "pure single-star passthrough": one whose entire export
  * surface is exactly one `export * from "x"` (no named/local/default-bearing
@@ -159,31 +351,62 @@ class SideEffectsFlagPlugin {
 			cache = new Map();
 			globToRegexpCache.set(compiler.root, cache);
 		}
+		let owningCache = owningSideEffectsFlagCache.get(compiler.root);
+		if (owningCache === undefined) {
+			owningCache = new Map();
+			owningSideEffectsFlagCache.set(compiler.root, owningCache);
+		}
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const moduleGraph = compilation.moduleGraph;
-				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
-					const resolveData = data.resourceResolveData;
-					if (
-						resolveData &&
-						resolveData.descriptionFileData &&
-						resolveData.relativePath
-					) {
-						const sideEffects = resolveData.descriptionFileData.sideEffects;
-						if (sideEffects !== undefined) {
-							if (module.factoryMeta === undefined) {
-								module.factoryMeta = {};
+				normalModuleFactory.hooks.afterResolve.tapAsync(
+					PLUGIN_NAME,
+					(resolveData, callback) => {
+						const inputFileSystem = compiler.inputFileSystem;
+						if (!inputFileSystem) return callback();
+						const { createData } = resolveData;
+						const resolveInfo = createData.resourceResolveData;
+						if (
+							!resolveInfo ||
+							!resolveInfo.descriptionFileData ||
+							!resolveInfo.relativePath
+						) {
+							return callback();
+						}
+						const descriptionFileRoot =
+							resolveInfo.descriptionFileRoot ||
+							(resolveInfo.descriptionFilePath
+								? dirname(inputFileSystem, resolveInfo.descriptionFilePath)
+								: undefined);
+						if (descriptionFileRoot === undefined) return callback();
+						resolveSideEffectsFlag(
+							inputFileSystem,
+							resolveData,
+							descriptionFileRoot,
+							owningCache,
+							(resolved) => {
+								if (resolved !== undefined) {
+									resolvedSideEffectsFlags.set(createData, resolved);
+								}
+								callback();
 							}
-							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
-								resolveData.relativePath,
-								/** @type {SideEffectsFlagValue} */ (sideEffects),
-								/** @type {CacheItem} */ (cache)
-							);
-							module.factoryMeta.sideEffectFree = !hasSideEffects;
+						);
+					}
+				);
+				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
+					const resolved = resolvedSideEffectsFlags.get(data);
+					if (resolved !== undefined) {
+						if (module.factoryMeta === undefined) {
+							module.factoryMeta = {};
 						}
+						const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
+							resolved.relativePath,
+							resolved.sideEffects,
+							/** @type {CacheItem} */ (cache)
+						);
+						module.factoryMeta.sideEffectFree = !hasSideEffects;
 					}
-
 					return module;
 				});
 				normalModuleFactory.hooks.module.tap(PLUGIN_NAME, (module, data) => {
@@ -529,7 +752,7 @@ class SideEffectsFlagPlugin {
 						// Re-export resolution is idempotent within a pass, so cache it
 						// per export info: a shared barrel imported by many modules
 						// resolves each name once instead of once per consumer.
-						/** @type {Map<ExportInfo, TargetItemWithConnection | null>} */
+						/** @type {Map<InstanceType<ExportInfo>, TargetItemWithConnection | null>} */
 						const reexportTargetCache = new Map();
 
 						// Dependencies don't change within the pass, so the passthrough

package/lib/optimize/SplitChunksPlugin.js

@@ -21,21 +21,28 @@ const { makePathsRelative } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const MinMaxSizeWarning = require("./MinMaxSizeWarning");
 
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksCacheGroup} OptimizationSplitChunksCacheGroup */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksOptions} OptimizationSplitChunksOptions */
-/** @typedef {import("../../declarations/WebpackOptions").OptimizationSplitChunksSizes} OptimizationSplitChunksSizes */
-/** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
-/** @typedef {import("../Chunk").ChunkName} ChunkName */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").SourceType} SourceType */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
+/**
+ * @import {
+ * 	OptimizationSplitChunksCacheGroup,
+ * 	OptimizationSplitChunksOptions,
+ * 	OptimizationSplitChunksSizes
+ * } from "../../declarations/WebpackOptions"
+ */
+/**
+ * @import {
+ * 	OutputNormalizedWithDefaults as OutputOptions
+ * } from "../config/defaults"
+ */
+/** @import { ChunkName, ChunkFilenameTemplate } from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import Module, { SourceType } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
 /** @typedef {import("../util/deterministicGrouping").GroupedItems<Module>} DeterministicGroupingGroupedItemsForModule */
 /** @typedef {import("../util/deterministicGrouping").Options<Module>} DeterministicGroupingOptionsForModule */
-/** @typedef {import("../util/deterministicGrouping").Sizes} Sizes */
+/** @import { Sizes } from "../util/deterministicGrouping" */
 
 /**
  * Defines the chunk filter fn callback.
@@ -212,6 +219,27 @@ const hashFilename = (name, outputOptions) => {
 	return digest.slice(0, 8);
 };
 
+/**
+ * A split `maxInitialRequests`/`maxAsyncRequests` refused, recorded for
+ * `performance.splitChunksCapped`.
+ * @typedef {object} CappedSplit
+ * @property {string} cacheGroup the cache group whose split was refused
+ * @property {Chunk} chunk the chunk it would have been taken out of
+ * @property {"maxAsyncRequests" | "maxInitialRequests"} limit the option that refused it
+ * @property {number} maxRequests the value that option had
+ * @property {number} modules how many modules the split would have moved
+ */
+
+/** @type {WeakMap<Compilation, CappedSplit[]>} */
+const CAPPED_SPLITS = new WeakMap();
+
+/**
+ * Reads back the splits a request cap refused during this compilation.
+ * @param {Compilation} compilation the compilation
+ * @returns {CappedSplit[] | undefined} the refused splits, or `undefined` when nothing recorded them
+ */
+const getCappedSplits = (compilation) => CAPPED_SPLITS.get(compilation);
+
 /**
  * Returns the number of requests.
  * @param {Chunk} chunk the chunk
@@ -690,7 +718,7 @@ const createCacheGroupSource = (options, key, defaultSizeTypes) => {
 
 const PLUGIN_NAME = "SplitChunksPlugin";
 
-module.exports = class SplitChunksPlugin {
+class SplitChunksPlugin {
 	/**
 	 * Creates an instance of SplitChunksPlugin.
 	 * @param {OptimizationSplitChunksOptions=} options plugin options
@@ -897,6 +925,19 @@ module.exports = class SplitChunksPlugin {
 				(chunks) => {
 					if (alreadyOptimized) return;
 					alreadyOptimized = true;
+					const { performance } = compilation.options;
+					// Mirrors both of `SplitChunksCappedPlugin`'s gates: a build that
+					// would not report records nothing and allocates nothing.
+					/** @type {CappedSplit[] | undefined} */
+					let cappedSplits;
+					if (
+						performance !== false &&
+						performance.splitChunksCapped === true &&
+						Boolean(performance.hints)
+					) {
+						cappedSplits = [];
+						CAPPED_SPLITS.set(compilation, cappedSplits);
+					}
 					logger.time("prepare");
 					const chunkGraph = compilation.chunkGraph;
 					const moduleGraph = compilation.moduleGraph;
@@ -1644,19 +1685,36 @@ module.exports = class SplitChunksPlugin {
 								Number.isFinite(item.cacheGroup.maxAsyncRequests))
 						) {
 							for (const chunk of usedChunks) {
-								// respect max requests
-								const maxRequests = chunk.isOnlyInitial()
-									? item.cacheGroup.maxInitialRequests
-									: chunk.canBeInitial()
-										? Math.min(
-												item.cacheGroup.maxInitialRequests,
-												item.cacheGroup.maxAsyncRequests
-											)
-										: item.cacheGroup.maxAsyncRequests;
+								// respect max requests: a chunk that is both initial and
+								// async answers to the stricter of the two caps
+								const isOnlyInitial = chunk.isOnlyInitial();
+								const byAsyncRequests =
+									!isOnlyInitial &&
+									(!chunk.canBeInitial() ||
+										item.cacheGroup.maxAsyncRequests <
+											item.cacheGroup.maxInitialRequests);
+								const maxRequests = byAsyncRequests
+									? item.cacheGroup.maxAsyncRequests
+									: item.cacheGroup.maxInitialRequests;
 								if (
 									Number.isFinite(maxRequests) &&
 									getRequests(chunk) >= maxRequests
 								) {
+									if (cappedSplits !== undefined) {
+										cappedSplits.push({
+											cacheGroup: item.cacheGroup.key,
+											chunk,
+											// which cap it was cannot be read back off the value:
+											// the two are equal by default in production
+											limit: byAsyncRequests
+												? "maxAsyncRequests"
+												: "maxInitialRequests",
+											maxRequests:
+												/** @type {number} */
+												(maxRequests),
+											modules: item.modules.size
+										});
+									}
 									usedChunks.delete(chunk);
 								}
 							}
@@ -1983,4 +2041,8 @@ module.exports = class SplitChunksPlugin {
 			);
 		});
 	}
-};
+}
+
+SplitChunksPlugin.getCappedSplits = getCappedSplits;
+
+module.exports = SplitChunksPlugin;

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -8,7 +8,7 @@
 const WebpackError = require("../errors/WebpackError");
 const formatSize = require("../util/formatSize");
 
-/** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
+/** @import { AssetDetails } from "./SizeLimitsPlugin" */
 
 class AssetsOverSizeLimitWarning extends WebpackError {
 	/**
@@ -18,7 +18,15 @@ class AssetsOverSizeLimitWarning extends WebpackError {
 	 */
 	constructor(assetsOverSizeLimit, assetLimit) {
 		const assetLists = assetsOverSizeLimit
-			.map((asset) => `\n  ${asset.name} (${formatSize(asset.size)})`)
+			.map((asset) => {
+				const largest = asset.modules
+					? `\n    Largest modules: ${asset.modules
+							.map((module) => `${module.name} (${formatSize(module.size)})`)
+							.join(", ")}`
+					: "";
+
+				return `\n  ${asset.name} (${formatSize(asset.size)})${largest}`;
+			})
 			.join("");
 
 		super(`asset size limit: The following asset(s) exceed the recommended size limit (${formatSize(

package/lib/performance/AsyncChunkWaterfallsPlugin.js

@@ -0,0 +1,136 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const AsyncChunkWaterfallWarning = require("../errors/AsyncChunkWaterfallWarning");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compiler from "../Compiler" */
+/** @import { WaterfallDetails } from "../errors/AsyncChunkWaterfallWarning" */
+
+const PLUGIN_NAME = "AsyncChunkWaterfallsPlugin";
+
+// Enough to name the offenders without printing the whole chunk graph.
+const MAX_REPORTED_WATERFALLS = 5;
+
+// Two levels is the shape `import()` is for — a route that loads its own data.
+// Three is where the round trips start outweighing what splitting saved.
+const MIN_REPORTED_DEPTH = 3;
+
+class AsyncChunkWaterfallsPlugin {
+	/**
+	 * Creates an instance of AsyncChunkWaterfallsPlugin.
+	 * @param {PerformanceOptions} options the plugin options
+	 */
+	constructor(options) {
+		/** @type {PerformanceOptions["hints"]} */
+		this.hints = options.hints;
+	}
+
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		const hints = this.hints;
+
+		if (!hints) return;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			// `afterSeal` is past the hash, which folds every message into it — a
+			// hint reported earlier would change the build's identity.
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { chunkGraph } = compilation;
+
+				/**
+				 * The name to print for a group; ids exist by `afterSeal`.
+				 * @param {ChunkGroup} group the group
+				 * @returns {string} what to call it
+				 */
+				const nameOf = (group) => {
+					if (group.name) return group.name;
+
+					const [chunk] = group.chunks;
+
+					return chunk && chunk.id !== null ? `${chunk.id}` : "(unnamed)";
+				};
+
+				// Breadth-first from the initial groups, so the depth recorded for a
+				// group is the fewest requests a client makes to reach it.
+				/** @type {Map<ChunkGroup, ChunkGroup[]>} */
+				const pathTo = new Map();
+				/** @type {ChunkGroup[]} */
+				const queue = [];
+
+				for (const group of compilation.chunkGroups) {
+					if (!group.isInitial()) continue;
+
+					pathTo.set(group, []);
+					queue.push(group);
+				}
+
+				/** @type {WaterfallDetails[]} */
+				const waterfalls = [];
+				let deepest = 0;
+
+				for (let i = 0; i < queue.length; i++) {
+					const group = queue[i];
+					const path = /** @type {ChunkGroup[]} */ (pathTo.get(group));
+
+					for (const child of group.getChildren()) {
+						if (pathTo.has(child)) continue;
+
+						const childPath = [...path, child];
+
+						pathTo.set(child, childPath);
+						queue.push(child);
+
+						if (childPath.length < MIN_REPORTED_DEPTH) continue;
+
+						// Only the end of a chain is reported: every prefix of it is a
+						// waterfall too, and naming them all says the same thing N times.
+						if (child.getNumberOfChildren() > 0) continue;
+
+						let size = 0;
+
+						for (const step of childPath) {
+							for (const chunk of step.chunks) {
+								size += chunkGraph.getChunkSize(chunk);
+							}
+						}
+
+						deepest = Math.max(deepest, childPath.length);
+						waterfalls.push({ chain: childPath.map(nameOf), size });
+					}
+				}
+
+				if (waterfalls.length === 0) return;
+
+				// Deepest first, then largest: the worst round-trip cost leads.
+				waterfalls.sort(
+					(a, b) => b.chain.length - a.chain.length || b.size - a.size
+				);
+
+				const warning = new AsyncChunkWaterfallWarning(
+					waterfalls.slice(0, MAX_REPORTED_WATERFALLS),
+					deepest
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = AsyncChunkWaterfallsPlugin;