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

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;

package/lib/performance/BroadContextsPlugin.js

@@ -0,0 +1,142 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const ContextModule = require("../ContextModule");
+const BroadContextsWarning = require("../errors/BroadContextsWarning");
+const { compareStrings } = require("../util/comparators");
+const getModuleSize = require("./getModuleSize");
+
+/** @typedef {import("../../declarations/WebpackOptions").PerformanceOptions} PerformanceOptions */
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../errors/BroadContextsWarning").BroadContextDetails} BroadContextDetails */
+
+const PLUGIN_NAME = "BroadContextsPlugin";
+
+// Enough to name the offenders without printing every context in the build.
+const MAX_REPORTED_CONTEXTS = 5;
+
+// A directory holding a handful of files costs little however it is matched,
+// and warning about it would bury the contexts that do carry weight.
+const MIN_REPORTED_MODULES = 20;
+
+// A bare leading wildcard takes every name in the directory, whether it is
+// `require.context`'s default or one webpack derived from an expression.
+const WILDCARD_PREFIX = "^\\.\\/.*";
+
+/**
+ * Whether a context takes whatever the directory holds. A pattern that narrows
+ * by anything other than a leading wildcard is left alone, as is one webpack
+ * cannot read — an unrecognized filter is never guessed at.
+ * @param {ContextModule} module a context module
+ * @returns {boolean} true when nothing narrows it
+ */
+const isBroad = (module) => {
+	const { regExp, include, exclude } = module.options;
+
+	if (include || exclude) return false;
+
+	return (
+		Boolean(regExp) &&
+		/** @type {RegExp} */ (regExp).source.startsWith(WILDCARD_PREFIX)
+	);
+};
+
+class BroadContextsPlugin {
+	/**
+	 * Creates an instance of BroadContextsPlugin.
+	 * @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 { moduleGraph, requestShortener } = compilation;
+				/** @type {BroadContextDetails[]} */
+				const broad = [];
+
+				for (const module of compilation.modules) {
+					if (!(module instanceof ContextModule)) continue;
+					if (!isBroad(module)) continue;
+
+					// One file is reached under several requests — with and without its
+					// extension — so the dependencies outnumber what is really matched.
+					/** @type {Set<Module>} */
+					const matched = new Set();
+
+					/**
+					 * @param {Dependency[]} dependencies the dependencies to walk
+					 * @returns {void}
+					 */
+					const collect = (dependencies) => {
+						for (const dependency of dependencies) {
+							const matchedModule = moduleGraph.getModule(dependency);
+
+							if (matchedModule) matched.add(matchedModule);
+						}
+					};
+
+					collect(module.dependencies);
+
+					// A lazy context keeps each match in a block of its own, so reading
+					// only `dependencies` would report it as matching nothing.
+					for (const block of module.blocks) collect(block.dependencies);
+
+					if (matched.size < MIN_REPORTED_MODULES) continue;
+
+					let size = 0;
+
+					for (const matchedModule of matched) {
+						size += getModuleSize(matchedModule);
+					}
+
+					broad.push({
+						name: module.readableIdentifier(requestShortener),
+						modules: matched.size,
+						size
+					});
+				}
+
+				if (broad.length === 0) return;
+
+				// Ties break by name: module order is not stable across runs.
+				broad.sort((a, b) => b.size - a.size || compareStrings(a.name, b.name));
+
+				const warning = new BroadContextsWarning(
+					broad.slice(0, MAX_REPORTED_CONTEXTS),
+					broad.length
+				);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = BroadContextsPlugin;

package/lib/performance/CacheEffectivenessPlugin.js

@@ -0,0 +1,125 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeModule = require("../RuntimeModule");
+const CacheEffectivenessWarning = require("../errors/CacheEffectivenessWarning");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import { BuildInfo } from "../Module" */
+
+const PLUGIN_NAME = "CacheEffectivenessPlugin";
+
+// A reason shared by many modules is the one worth fixing, so report the
+// frequent ones and count the rest.
+const MAX_REPORTED_REASONS = 3;
+
+const UNSPECIFIED_REASON = "reason not stated";
+
+class CacheEffectivenessPlugin {
+	/**
+	 * Creates an instance of CacheEffectivenessPlugin.
+	 * @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) => {
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				let total = 0;
+				let rebuilt = 0;
+				let uncacheable = 0;
+				/** @type {Map<string, number>} */
+				const modulesByReason = new Map();
+
+				for (const module of compilation.modules) {
+					// Runtime modules are generated per compilation, never built and
+					// never cached, so counting them makes a cold build look warm.
+					if (module instanceof RuntimeModule) continue;
+
+					total++;
+
+					if (compilation.builtModules.has(module)) rebuilt++;
+
+					// Every built module carries one; `cacheable` being `undefined` is
+					// the module never reporting either way, not it opting out.
+					const buildInfo = /** @type {BuildInfo} */ (module.buildInfo);
+
+					if (buildInfo.cacheable !== false) continue;
+
+					uncacheable++;
+
+					const reasons =
+						buildInfo.notCacheableReasons &&
+						buildInfo.notCacheableReasons.length > 0
+							? buildInfo.notCacheableReasons
+							: [UNSPECIFIED_REASON];
+
+					for (const reason of reasons) {
+						modulesByReason.set(reason, (modulesByReason.get(reason) || 0) + 1);
+					}
+				}
+
+				// Work redone despite a warm cache needs both ends: everything rebuilt
+				// is a cold build, nothing rebuilt is the cache working.
+				const warmRebuild = rebuilt > 0 && rebuilt < total;
+
+				if (!warmRebuild && uncacheable === 0) return;
+
+				// Most frequent first, and by reason where two are as frequent: the
+				// map is keyed in the order the modules were walked, which is not the
+				// same twice, and only three reasons are reported — so an unbroken tie
+				// would vary which of them a build names at all.
+				const sorted = [...modulesByReason].sort(
+					(a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
+				);
+				const reasons = sorted
+					.slice(0, MAX_REPORTED_REASONS)
+					.map(
+						([reason, modules]) =>
+							`${reason} (${modules} ${modules === 1 ? "module" : "modules"})`
+					);
+				const remaining = sorted.length - reasons.length;
+
+				if (remaining > 0) {
+					reasons.push(
+						`and ${remaining} other ${remaining === 1 ? "reason" : "reasons"}`
+					);
+				}
+
+				const warning = new CacheEffectivenessWarning({
+					total,
+					rebuilt,
+					uncacheable,
+					reasons
+				});
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = CacheEffectivenessPlugin;

package/lib/performance/ConflictingResourceHintsPlugin.js

@@ -0,0 +1,99 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const ConflictingResourceHintsWarning = require("../errors/ConflictingResourceHintsWarning");
+const { compareStrings } = require("../util/comparators");
+
+/** @import { PerformanceOptions } from "../../declarations/WebpackOptions" */
+/** @import ChunkGroup from "../ChunkGroup" */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import {
+ * 	ConflictingResourceHintDetails
+ * } from "../errors/ConflictingResourceHintsWarning"
+ */
+
+const PLUGIN_NAME = "ConflictingResourceHintsPlugin";
+
+/**
+ * Names a chunk group for a message, falling back to its chunks: an `import()`
+ * without `webpackChunkName` produces a group with no name of its own.
+ * @param {ChunkGroup} chunkGroup a chunk group
+ * @returns {string} a name for it
+ */
+const getChunkGroupName = (chunkGroup) =>
+	chunkGroup.name ||
+	chunkGroup.chunks.map((chunk) => chunk.name || `${chunk.id}`).join(", ");
+
+class ConflictingResourceHintsPlugin {
+	/**
+	 * Creates an instance of ConflictingResourceHintsPlugin.
+	 * @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;
+
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.afterSeal.tap(PLUGIN_NAME, () => {
+				const { chunkGraph, moduleGraph } = compilation;
+				/** @type {ConflictingResourceHintDetails[]} */
+				const links = [];
+
+				for (const chunkGroup of compilation.chunkGroups) {
+					const children = chunkGroup.getChildrenByOrders(
+						moduleGraph,
+						chunkGraph
+					);
+
+					if (!children.prefetch || !children.preload) continue;
+
+					const preloaded = new Set(children.preload);
+
+					for (const child of children.prefetch) {
+						if (!preloaded.has(child)) continue;
+
+						links.push({
+							parent: getChunkGroupName(chunkGroup),
+							child: getChunkGroupName(child)
+						});
+					}
+				}
+
+				if (links.length === 0) return;
+
+				// Chunk group iteration order is not stable across runs.
+				links.sort(
+					(a, b) =>
+						compareStrings(a.parent, b.parent) ||
+						compareStrings(a.child, b.child)
+				);
+
+				const warning = new ConflictingResourceHintsWarning(links);
+
+				if (hints === "error") {
+					compilation.errors.push(warning);
+				} else if (hints === "stats") {
+					compilation.hints.push(warning);
+				} else {
+					compilation.warnings.push(warning);
+				}
+			});
+		});
+	}
+}
+
+module.exports = ConflictingResourceHintsPlugin;