webpack 5.111.0 → 5.112.0

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 const lazyModule = require("../util/lazyModule");
 
 /** @import Compiler from "../Compiler" */
@@ -83,10 +83,9 @@ class ChunkPrefetchPreloadPlugin {
 						);
 					}
 					if (chunkMap.cssPreload) {
-						// CSS-only preload (`parser.javascript.dynamicImportCssPreload`):
-						// the trigger reaches the CSS `.s` handler itself
-						// (`<link rel="preload" as="style">`), so it asks for the handlers
-						// alone — nothing here calls the one that fans out over them.
+						// A CSS-only preload reaches the CSS handler itself, so it asks for
+						// the handlers alone: nothing here calls the function fanning out
+						// across them.
 						set.add(RuntimeGlobals.preloadChunkHandlers);
 						compilation.addLazyRuntimeModule(
 							chunk,
@@ -96,10 +95,9 @@ class ChunkPrefetchPreloadPlugin {
 					}
 				}
 			);
-			// The handlers object is what carries the runtime module, so a chunk asking
-			// only for it — a trigger that reaches one handler by name — ships no
-			// fan-out function. Whether one is wanted is read here rather than in
-			// `create`, which runs after the requirement pass is over.
+			// The handlers object carries the runtime module, so a chunk asking only for
+			// it ships no fan-out function. That is read here rather than in `create`,
+			// which runs once the requirement pass is over.
 			for (const [type, fn, handlers] of /** @type {const} */ ([
 				[
 					"prefetch",

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -4,11 +4,11 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const RuntimeModule = require("../runtime/RuntimeModule");
+const Template = require("../template/Template");
 
-/** @import Chunk, { ChunkChildOfTypeInOrder } from "../Chunk" */
+/** @import Chunk, { ChunkChildOfTypeInOrder } from "../graph/Chunk" */
 /** @import Compilation from "../Compilation" */
 
 class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -4,12 +4,12 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const RuntimeModule = require("../runtime/RuntimeModule");
+const Template = require("../template/Template");
 
 /** @import Compilation from "../Compilation" */
-/** @import { ChunkChildIdsByOrdersMap } from "../Chunk" */
+/** @import { ChunkChildIdsByOrdersMap } from "../graph/Chunk" */
 
 class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	/**

package/lib/prefetch/ChunkPreloadTriggerRuntimeModule.js

@@ -4,12 +4,12 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const RuntimeModule = require("../runtime/RuntimeModule");
+const Template = require("../template/Template");
 
 /** @import Compilation from "../Compilation" */
-/** @import { ChunkChildIdsByOrdersMap } from "../Chunk" */
+/** @import { ChunkChildIdsByOrdersMap } from "../graph/Chunk" */
 
 class ChunkPreloadTriggerRuntimeModule extends RuntimeModule {
 	/**

package/lib/{dependencies → prefetch}/PrefetchDependency.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const ModuleDependency = require("./ModuleDependency");
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
 
 class PrefetchDependency extends ModuleDependency {
 	/**

package/lib/{PrefetchPlugin.js → prefetch/PrefetchPlugin.js}

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const PrefetchDependency = require("./dependencies/PrefetchDependency");
+const PrefetchDependency = require("./PrefetchDependency");
 
-/** @import Compiler from "./Compiler" */
+/** @import Compiler from "../Compiler" */
 
 const PLUGIN_NAME = "PrefetchPlugin";
 

package/lib/prefetch/ResourceHintPlugin.js

@@ -5,18 +5,13 @@
 "use strict";
 
 const { RawSource } = require("webpack-sources");
-const ModuleFilenameHelpers = require("../ModuleFilenameHelpers");
+const isDependencyKind = require("../graph/isDependencyKind");
 const {
 	ASSET_URL_TYPE,
 	JAVASCRIPT_TYPE
-} = require("../ModuleSourceTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const CssUrlDependency = require("../dependencies/CssUrlDependency");
-const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
-const URLDependency = require("../dependencies/URLDependency");
-const WorkerDependency = require("../dependencies/WorkerDependency");
+} = require("../module/ModuleSourceTypeConstants");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 const lazyModule = require("../util/lazyModule");
-const memoize = require("../util/memoize");
 const {
 	PUBLIC_PATH_AUTO,
 	PUBLIC_PATH_FULL_HASH
@@ -24,12 +19,15 @@ const {
 const { guessAsAttribute } = require("./parseResourceHintOptions");
 const parseResourceHintOptions = require("./parseResourceHintOptions");
 
-/** @import Chunk from "../Chunk" */
-/** @import ChunkGraph from "../ChunkGraph" */
-/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import CssUrlDependency from "../dependencies/css/CssUrlDependency" */
+/** @import HtmlSourceDependency from "../dependencies/html/HtmlSourceDependency" */
+/** @import URLDependency from "../dependencies/url/URLDependency" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
-/** @import Module, { RuntimeRequirements } from "../Module" */
+/** @import Module, { RuntimeRequirements } from "../module/Module" */
 
 /**
  * The attributes a `<link>` carries besides its href and `as`.
@@ -55,11 +53,14 @@ const parseResourceHintOptions = require("./parseResourceHintOptions");
  * @import {
  * 	ResourceHintsInitial as ResourceHintsConfig,
  * 	ResourceHintsOptions,
+ * 	RuleSetCondition,
+ * 	RuleSetLogicalConditions,
  * 	UrlHintRule
  * } from "../../declarations/WebpackOptions"
  */
-/** @import { HtmlResourceHint } from "../dependencies/HtmlEntryDependency" */
+/** @import { HtmlResourceHint } from "../dependencies/html/HtmlEntryDependency" */
 /** @import { ResourceHintOptions } from "./parseResourceHintOptions" */
+/** @import { MagicCommentOptions } from "../util/magicComment" */
 
 /**
  * @typedef {object} ResolvedResourceHints
@@ -136,9 +137,6 @@ const getStartupAssetHintRuntimeModule = lazyModule(() =>
 );
 // only reached once a build has an html module, so a js-only build never
 // pays for the html generator this drags in
-const getHtmlEntryDependency = memoize(() =>
-	require("../dependencies/HtmlEntryDependency")
-);
 
 const PLUGIN_NAME = "ResourceHintPlugin";
 
@@ -156,18 +154,18 @@ const JS_CHUNK_FILE_REGEXP = /\.m?jsx?$/i;
 /**
  * True for the URL-referenced-asset deps that can carry resource-hint flags.
  * Type guard so callers keep the narrowed union without re-listing the classes.
- * @param {import("../Dependency")} dep dependency
+ * @param {import("../graph/Dependency")} dep dependency
  * @returns {dep is URLDependency | CssUrlDependency | HtmlSourceDependency} whether it is a URL asset dep
  */
 const isUrlAssetDep = (dep) =>
-	dep instanceof URLDependency ||
-	dep instanceof CssUrlDependency ||
-	dep instanceof HtmlSourceDependency;
+	isDependencyKind(dep, "url") ||
+	isDependencyKind(dep, "css-url") ||
+	isDependencyKind(dep, "html-source");
 
 /**
  * Entry chunk name for a hint's `hostChunks` (Vite's `hostId`); the id is a
  * stable fallback for unnamed chunks.
- * @param {import("../Chunk")} chunk chunk
+ * @param {import("../graph/Chunk")} chunk chunk
  * @returns {string} name or stringified id
  */
 const chunkHostName = (chunk) => chunk.name || String(chunk.id);
@@ -178,8 +176,8 @@ const chunkHostName = (chunk) => chunk.name || String(chunk.id);
  * single call. One shared walk for the entrypoint-hint and HTML-hint passes,
  * which would otherwise each re-implement the same 4-level nesting.
  * @param {Compilation} compilation compilation
- * @param {Iterable<import("../Chunk")>} chunks chunks to scan
- * @returns {IterableIterator<{ dep: URLDependency | CssUrlDependency | HtmlSourceDependency, target: Module, chunk: import("../Chunk") }>} hinted assets
+ * @param {Iterable<import("../graph/Chunk")>} chunks chunks to scan
+ * @returns {IterableIterator<{ dep: URLDependency | CssUrlDependency | HtmlSourceDependency, target: Module, chunk: import("../graph/Chunk") }>} hinted assets
  */
 function* iterateHintedUrlAssets(compilation, chunks) {
 	const { chunkGraph, moduleGraph } = compilation;
@@ -201,6 +199,38 @@ function* iterateHintedUrlAssets(compilation, chunks) {
 	}
 }
 
+/** @type {WeakMap<UrlHintRule, (request: string) => boolean>} */
+const urlHintMatchers = new WeakMap();
+
+/**
+ * A rule's `test`, `include` and `exclude` as one predicate, read as `module.rules`
+ * reads a condition, so `and`/`or`/`not`/`glob` work too. Compiled once per rule.
+ * @param {UrlHintRule} rule rule setting at least one of the three
+ * @returns {(request: string) => boolean} whether the rule applies to a request
+ */
+const getUrlHintMatcher = (rule) => {
+	let matcher = urlHintMatchers.get(rule);
+	if (matcher === undefined) {
+		/** @type {RuleSetCondition[]} */
+		const all = [];
+		if (rule.test !== undefined) all.push(rule.test);
+		if (rule.include !== undefined) all.push(rule.include);
+		/** @type {RuleSetLogicalConditions} */
+		const condition = {};
+		if (all.length > 0) condition.and = all;
+		if (rule.exclude !== undefined) condition.not = rule.exclude;
+
+		const RuleSetCompiler = require("../rules/RuleSetCompiler");
+
+		matcher = new RuleSetCompiler([]).compileCondition(
+			"urlHints",
+			condition
+		).fn;
+		urlHintMatchers.set(rule, matcher);
+	}
+	return matcher;
+};
+
 /**
  * Merge the matching `UrlHintRule`s for a request. Rules match by
  * `test`/`include`/`exclude` (omit all three → matches everything); later
@@ -219,14 +249,7 @@ const matchUrlHints = (rules, request) => {
 			(rule.test !== undefined ||
 				rule.include !== undefined ||
 				rule.exclude !== undefined) &&
-			!ModuleFilenameHelpers.matchObject(
-				/** @type {EXPECTED_ANY} */ ({
-					test: rule.test,
-					include: rule.include,
-					exclude: rule.exclude
-				}),
-				request
-			)
+			!getUrlHintMatcher(rule)(request)
 		) {
 			continue;
 		}
@@ -246,7 +269,7 @@ const matchUrlHints = (rules, request) => {
  * When `output.resourceHints` is a function, invoke it and return its
  * descriptors; otherwise pass through. Callback signature — see `ResourceHints`
  * schema entry.
- * @param {import("../Entrypoint")} entrypoint entrypoint
+ * @param {import("../graph/Entrypoint")} entrypoint entrypoint
  * @param {ResourceHintsConfig | undefined} hints top-level config
  * @param {string} entryName entry name
  * @param {"html" | "js"} hostType page type
@@ -360,7 +383,7 @@ const collectEntrypointHints = (compilation, entryName, hints) => {
 	// URL-referenced deps carrying prefetch/preload. Walk entrypoint's initial
 	// chunks × modules × deps (async chunks are handled by the on-demand
 	// runtime via `dynamicImportPrefetch/Preload` parser options).
-	/** @type {Set<import("../Chunk")>} */
+	/** @type {Set<import("../graph/Chunk")>} */
 	const chunkSet = new Set(entrypoint.chunks);
 	const runtimeChunk = entrypoint.getRuntimeChunk();
 	if (runtimeChunk) chunkSet.add(runtimeChunk);
@@ -385,10 +408,9 @@ const collectEntrypointHints = (compilation, entryName, hints) => {
 		if (dep.fetchPriority) h.fetchPriority = dep.fetchPriority;
 		push(h);
 	}
-	// `hostType`: `"html"` iff the entrypoint has an extracted HTML page
-	// (any `HtmlEntryDependency` with elementKind `script`/`script-module` on
-	// any HTML module points at this entryName); SSR frameworks reading
-	// `stats.entrypoints[name].resourceHints` see `"js"`.
+	// `hostType` is `"html"` only where the entrypoint has an extracted page, that
+	// is where some HTML module's script dependency names this entry. An SSR
+	// framework reading the stats sees `"js"`.
 	let hostType = /** @type {"html" | "js"} */ ("js");
 
 	outer: for (const module of compilation.modules) {
@@ -397,10 +419,9 @@ const collectEntrypointHints = (compilation, entryName, hints) => {
 		}
 		const presDeps = module.presentationalDependencies;
 		if (!presDeps) continue;
-		const HtmlEntryDependency = getHtmlEntryDependency();
 		for (const dep of presDeps) {
 			if (
-				dep instanceof HtmlEntryDependency &&
+				isDependencyKind(dep, "html-entry") &&
 				dep.entryName === entryName &&
 				(dep.elementKind === "script" || dep.elementKind === "script-module")
 			) {
@@ -472,13 +493,13 @@ const collectStartupAssetHintLines = (
 	for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 		for (const block of module.blocks) {
 			for (const dep of block.dependencies) {
-				if (!(dep instanceof WorkerDependency)) continue;
+				if (!isDependencyKind(dep, "worker")) continue;
 				const hint = dep.options.resourceHint;
 				if (!hint || (!hint.preload && !hint.prefetch)) continue;
 				const group = chunkGraph.getBlockChunkGroup(block);
 				if (!group) continue;
 				const workerChunk =
-					/** @type {import("../Entrypoint")} */
+					/** @type {import("../graph/Entrypoint")} */
 					(group).getEntrypointChunk();
 				if (workerChunk.id === null || seenWorkerChunks.has(workerChunk.id)) {
 					continue;
@@ -513,7 +534,7 @@ const collectStartupAssetHintLines = (
 	const perAsset = new Map();
 	for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
 		const deps =
-			/** @type {{ dependencies?: import("../Dependency")[] }} */
+			/** @type {{ dependencies?: import("../graph/Dependency")[] }} */
 			(module).dependencies;
 		if (!deps) continue;
 		for (const dep of deps) {
@@ -715,9 +736,9 @@ class ResourceHintPlugin {
 	 * @param {ResourceHintDep} dep dep to mutate in place
 	 * @param {UrlHintRule[] | undefined} rules parser-scoped `urlHints` rules
 	 * @param {string} request the asset request (for rule matching)
-	 * @param {Record<string, EXPECTED_ANY> | null | undefined} commentOptions parsed magic-comment options (`null` / `undefined` skips override phase)
-	 * @param {import("../NormalModule")} module module for emitting warnings on invalid comments
-	 * @param {import("../Dependency").DependencyLocation} loc loc for warnings
+	 * @param {MagicCommentOptions | null | undefined} commentOptions parsed magic-comment options (`null` / `undefined` skips override phase)
+	 * @param {import("../module/NormalModule")} module module for emitting warnings on invalid comments
+	 * @param {import("../graph/Dependency").DependencyLocation} loc loc for warnings
 	 * @returns {void}
 	 */
 	static applyResourceHints(dep, rules, request, commentOptions, module, loc) {
@@ -737,15 +758,14 @@ class ResourceHintPlugin {
 		const hints = this._hints;
 
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-			// Lazy-computed on first access — walk every HTML module's
-			// `HtmlEntryDependency`s, resolve each named entry, and collect
-			// every URL asset dep target reachable from its ordered chunks.
-			// One pass produces two views: a per-entry list (consumed by
-			// `HtmlEntryDependency.Template` to emit `<link>` tags) and a
-			// global `WeakSet` (consumed by `StartupAssetHintRuntimeModule`
-			// to skip the JS runtime `<link>` for the same asset).
-			// Deterministic (module graph is fixed by seal time) and cheap
-			// (only fires when a JS chunk actually produces hints).
+			// WHY: computed on first access. One walk of every HTML module's
+			// `HtmlEntryDependency`s — resolving each named entry and collecting every
+			// URL asset dep reachable from its ordered chunks — yields both views: a
+			// per-entry list, which `HtmlEntryDependency.Template` emits the `<link>`
+			// tags from, and a global `WeakSet`, which `StartupAssetHintRuntimeModule`
+			// reads to skip the JS runtime `<link>` for the same asset. Deterministic,
+			// the module graph being fixed by seal time, and cheap, since it only fires
+			// when a JS chunk actually produces hints.
 			/** @type {Map<string, HtmlHintedAsset[]> | undefined} */
 			let perEntry;
 			/** @type {WeakSet<Module> | undefined} */
@@ -762,10 +782,9 @@ class ResourceHintPlugin {
 					// they don't affect module resolution, only rendering.
 					const presDeps = module.presentationalDependencies;
 					if (!presDeps) continue;
-					const HtmlEntryDependency = getHtmlEntryDependency();
 					for (const dep of presDeps) {
 						if (
-							!(dep instanceof HtmlEntryDependency) ||
+							!isDependencyKind(dep, "html-entry") ||
 							(dep.elementKind !== "script" &&
 								dep.elementKind !== "script-module")
 						) {
@@ -773,11 +792,10 @@ class ResourceHintPlugin {
 						}
 						const entrypoint = compilation.entrypoints.get(dep.entryName);
 						if (!entrypoint) continue;
-						// Mirror `getEntrypointChunksInLoadOrder`: entry chunk +
-						// runtime chunk + all initial siblings (`entrypoint.chunks`
-						// includes splitChunks output). Async `import()` chunks
-						// stay on the on-demand runtime and are NOT HTML-hinted.
-						/** @type {Set<import("../Chunk")>} */
+						// Mirrors `getEntrypointChunksInLoadOrder`: the entry, runtime and
+						// every initial sibling. An async `import()` chunk stays on the
+						// on-demand runtime and is never HTML-hinted.
+						/** @type {Set<import("../graph/Chunk")>} */
 						const chunks = new Set(entrypoint.chunks);
 						const entry = entrypoint.getEntrypointChunk();
 						if (entry) chunks.add(entry);
@@ -864,10 +882,9 @@ class ResourceHintPlugin {
 					});
 			}
 
-			// SSR manifest: serialize each entrypoint's resolved hints to a JSON
-			// asset (the same descriptors as `stats.entrypoints[].resourceHints`)
-			// so an SSR server can inject the `<link>` tags itself. `"none"`
-			// yields empty lists (via `collectEntrypointHints`).
+			// The SSR manifest serializes each entrypoint's resolved hints to a JSON
+			// asset, the same descriptors the stats carry, so an SSR server can inject
+			// the tags itself. `"none"` yields empty lists.
 			const rhOptions = compilation.outputOptions.resourceHints;
 			const manifestPath = rhOptions && rhOptions.manifest;
 			if (manifestPath) {

package/lib/prefetch/ResourceHintRuntimeModule.js

@@ -6,9 +6,9 @@
 
 const { SyncWaterfallHook } = require("tapable");
 const Compilation = require("../Compilation");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const RuntimeModule = require("../runtime/RuntimeModule");
+const Template = require("../template/Template");
 const { guessAsAttribute } = require("./parseResourceHintOptions");
 
 /**

package/lib/prefetch/StartupAssetHintRuntimeModule.js

@@ -4,9 +4,9 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const RuntimeModule = require("../runtime/RuntimeModule");
+const Template = require("../template/Template");
 
 /** @import Compilation from "../Compilation" */
 
@@ -47,16 +47,13 @@ class StartupAssetHintRuntimeModule extends RuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const lines = this._lines;
 		if (lines.length === 0) return null;
-		// `__webpack_nonce__` set inside the entry module is too late — the
-		// entry hasn't run yet. Read the nonce off the `<script>` tag that
-		// loaded the bundle, so prefetch / preload links match a CSP that
-		// demands the same nonce as the script.
-		//
-		// - For classic script output, `document.currentScript` is the
-		//   loading `<script>` element while the runtime executes.
-		// - For ESM output (`output.module: true`), `document.currentScript`
-		//   is `null`; locate the loading `<script type="module">` by
-		//   matching `script.src` against `import.meta.url`.
+		// `__webpack_nonce__` set in the entry module comes too late, the entry not
+		// having run, so the nonce is read off the `<script>` that loaded the bundle
+		// and the links match a CSP demanding the script's own.
+
+		// Classic output finds it on `document.currentScript`. ESM output leaves that
+		// null, so the loading `<script type="module">` is found by matching its
+		// `src` against `import.meta.url`.
 		const { module: isModule, importMetaName } = compilation.outputOptions;
 		const nonceSetup = isModule
 			? [

package/lib/prefetch/parseResourceHintOptions.js

@@ -10,8 +10,9 @@ const getUnsupportedFeatureWarning = memoize(() =>
 	require("../errors/UnsupportedFeatureWarning")
 );
 
-/** @import { DependencyLocation } from "../Dependency" */
-/** @import NormalModule from "../NormalModule" */
+/** @import { DependencyLocation } from "../graph/Dependency" */
+/** @import NormalModule from "../module/NormalModule" */
+/** @import { MagicCommentOptions } from "../util/magicComment" */
 
 /**
  * @typedef {object} ResourceHintOptions
@@ -27,7 +28,7 @@ const getUnsupportedFeatureWarning = memoize(() =>
  * Reads `webpackPrefetch` / `webpackPreload` / `webpackFetchPriority` /
  * `webpackAs` / `webpackType` / `webpackMedia` from a parsed magic-comment
  * options object. Invalid values emit warnings to the given module.
- * @param {Record<string, EXPECTED_ANY> | null | undefined} importOptions parsed comment options
+ * @param {MagicCommentOptions | null | undefined} importOptions parsed comment options
  * @param {NormalModule} module the module to attach warnings to
  * @param {DependencyLocation} loc location for warnings
  * @returns {ResourceHintOptions} parsed hints (empty when no comments matched)

package/lib/{ProvidePlugin.js → provide/ProvidePlugin.js}

@@ -5,18 +5,18 @@
 
 "use strict";
 
+const ConstDependency = require("../dependencies/core/ConstDependency");
+const { approve } = require("../javascript/JavascriptParserHelpers");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
 	JAVASCRIPT_MODULE_TYPE_ESM
-} = require("./ModuleTypeConstants");
-const ConstDependency = require("./dependencies/ConstDependency");
-const ProvidedDependency = require("./dependencies/ProvidedDependency");
-const { approve } = require("./javascript/JavascriptParserHelpers");
+} = require("../module/ModuleTypeConstants");
+const ProvidedDependency = require("./ProvidedDependency");
 
-/** @import { JavascriptParserOptions } from "../declarations/WebpackOptions" */
-/** @import Compiler from "./Compiler" */
-/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
+/** @import { JavascriptParserOptions } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
+/** @import JavascriptParser, { Range } from "../javascript/JavascriptParser" */
 
 const PLUGIN_NAME = "ProvidePlugin";
 

package/lib/{dependencies → provide}/ProvidedDependency.js

@@ -5,13 +5,13 @@
 
 "use strict";
 
-const Dependency = require("../Dependency");
-const InitFragment = require("../InitFragment");
-const Template = require("../Template");
-const { InlinedUsedName } = require("../optimize/InlineExports");
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
+const Dependency = require("../graph/Dependency");
+const { isInlinedUsedName } = require("../optimize/InlineExports");
+const InitFragment = require("../template/InitFragment");
+const Template = require("../template/Template");
 const makeSerializable = require("../util/makeSerializable");
 const { propertyAccess } = require("../util/property");
-const ModuleDependency = require("./ModuleDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
 /**
@@ -19,11 +19,11 @@ const ModuleDependency = require("./ModuleDependency");
  * 	ReferencedExports,
  * 	UpdateHashContext,
  * 	ExportInfoName
- * } from "../Dependency"
+ * } from "../graph/Dependency"
  */
-/** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import ModuleGraphConnection from "../ModuleGraphConnection" */
+/** @import { DependencyTemplateContext } from "../template/DependencyTemplate" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import ModuleGraphConnection from "../graph/ModuleGraphConnection" */
 /** @import { Range } from "../javascript/JavascriptParser" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, ExportInfoName[]]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, ExportInfoName[]]>} ObjectSerializerContext */
@@ -103,10 +103,11 @@ class ProvidedDependency extends ModuleDependency {
 	}
 }
 
-makeSerializable(
-	ProvidedDependency,
+makeSerializable(ProvidedDependency, [
+	"webpack/lib/provide/ProvidedDependency",
+	// TODO in the next major release: remove, they restore pre-move cache packs
 	"webpack/lib/dependencies/ProvidedDependency"
-);
+]);
 
 class ProvidedDependencyTemplate extends ModuleDependency.Template {
 	/**
@@ -144,7 +145,7 @@ class ProvidedDependencyTemplate extends ModuleDependency.Template {
 
 		const provided = !usedName
 			? moduleRaw
-			: usedName instanceof InlinedUsedName
+			: isInlinedUsedName(usedName)
 				? `(${moduleRaw}, ${usedName.render(
 						Template.toNormalComment(
 							`inlined export ${propertyAccess(dep.ids)}`

package/lib/{IgnorePlugin.js → resolve/IgnorePlugin.js}

@@ -5,19 +5,36 @@
 
 "use strict";
 
-const RawModule = require("./RawModule");
-const EntryDependency = require("./dependencies/EntryDependency");
+const isDependencyKind = require("../graph/isDependencyKind");
+const RawModule = require("../module/RawModule");
+
+/** @import Compiler from "../Compiler" */
+/** @import { ResolveData } from "../module/NormalModuleFactory" */
+/** @import { BeforeContextResolveData } from "../context/ContextModuleFactory" */
 
 /**
- * @import {
- * 	IgnorePluginOptions
- * } from "../declarations/plugins/IgnorePlugin"
+ * @inline
+ * @tsType import('./IgnorePlugin').CheckResourceFn
+ * @typedef {(resource: string, context: string) => boolean} CheckResourceFn
  */
-/** @import Compiler from "./Compiler" */
-/** @import { ResolveData } from "./NormalModuleFactory" */
-/** @import { BeforeContextResolveData } from "./ContextModuleFactory" */
 
-/** @typedef {(resource: string, context: string) => boolean} CheckResourceFn */
+/**
+ * @inline
+ * @typedef {object} IgnorePluginPatternOptions
+ * @property {RegExp=} contextRegExp A RegExp to test the context (directory) against.
+ * @property {RegExp} resourceRegExp A RegExp to test the request against.
+ */
+
+/**
+ * @inline
+ * @typedef {object} IgnorePluginCheckOptions
+ * @property {CheckResourceFn} checkResource A filter function for resource and context.
+ */
+
+/**
+ * @schema plugins/IgnorePlugin
+ * @typedef {IgnorePluginPatternOptions | IgnorePluginCheckOptions} IgnorePluginOptions
+ */
 
 const PLUGIN_NAME = "IgnorePlugin";
 
@@ -71,14 +88,14 @@ class IgnorePlugin {
 	apply(compiler) {
 		compiler.hooks.validate.tap(PLUGIN_NAME, () => {
 			compiler.validate(
-				/** @type {EXPECTED_ANY} */
-				(require("../schemas/plugins/IgnorePlugin.json")),
+				require("../../schemas/plugins/IgnorePlugin.json"),
 				this.options,
 				{
 					name: "Ignore Plugin",
 					baseDataPath: "options"
 				},
-				(options) => require("../schemas/plugins/IgnorePlugin.check")(options)
+				(options) =>
+					require("../../schemas/plugins/IgnorePlugin.check")(options)
 			);
 		});
 
@@ -89,7 +106,7 @@ class IgnorePlugin {
 				if (
 					result === false &&
 					resolveData.dependencies.length > 0 &&
-					resolveData.dependencies[0] instanceof EntryDependency
+					isDependencyKind(resolveData.dependencies[0], "entry")
 				) {
 					const module = new RawModule(
 						"",