@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.1

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);
@@ -396,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")
 			) {
@@ -471,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;
@@ -512,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) {
@@ -714,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) {
@@ -760,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")
 						) {
@@ -774,7 +795,7 @@ class ResourceHintPlugin {
 						// 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("../Chunk")>} */
+						/** @type {Set<import("../graph/Chunk")>} */
 						const chunks = new Set(entrypoint.chunks);
 						const entry = entrypoint.getEntrypointChunk();
 						if (entry) chunks.add(entry);

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" */
 

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 "./context/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(
 						"",

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

@@ -5,11 +5,11 @@
 
 "use strict";
 
-const { dirname, isAbsolute, join } = require("./util/fs");
+const { dirname, isAbsolute, join } = require("../fs/fs");
 
-/** @import Compiler from "./Compiler" */
-/** @import { ResolveData } from "./NormalModuleFactory" */
-/** @import { InputFileSystem } from "./util/fs" */
+/** @import Compiler from "../Compiler" */
+/** @import { ResolveData } from "../module/NormalModuleFactory" */
+/** @import { InputFileSystem } from "../fs/fs" */
 
 /** @typedef {(resolveData: ResolveData) => void} ModuleReplacer */
 

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

@@ -11,12 +11,16 @@ const {
 	cachedCleverMerge,
 	removeOperations,
 	resolveByProperty
-} = require("./util/cleverMerge");
+} = require("../util/cleverMerge");
+const memoize = require("../util/memoize");
+const getResolveOptionsKey = require("./getResolveOptionsKey");
+
+const getGlobUtils = memoize(() => require("../util/globUtils"));
 
 /** @typedef {import("enhanced-resolve").Resolver} Resolver */
-/** @typedef {import("../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
+/** @typedef {import("../../declarations/WebpackOptions").ResolvePluginInstance} ResolvePluginInstance */
 /** @import { ResolveOptions } from "enhanced-resolve" */
-/** @import { ResolveOptions as WebpackResolveOptions } from "../declarations/WebpackOptions" */
+/** @import { ResolveOptions as WebpackResolveOptions } from "../../declarations/WebpackOptions" */
 
 /** @typedef {WebpackResolveOptions & { dependencyType?: string, resolveToContext?: boolean }} ResolveOptionsWithDependencyType */
 /**
@@ -61,13 +65,22 @@ const convertToResolveOptions = (resolveOptionsWithDepType) => {
 			partialOptions
 		);
 
-	return /** @type {ResolveOptions} */ (
+	const resolveOptions = /** @type {ResolveOptions} */ (
 		removeOperations(
 			resolveByProperty(options, "byDependency", dependencyType),
 			// Keep the `unsafeCache` because it can be a `Proxy`
 			["unsafeCache"]
 		)
 	);
+	if (resolveOptions.restrictions) {
+		// enhanced-resolve reads a string as a directory, so a glob goes as a RegExp
+		const { compileRelativeGlobPaths, createPathGlobRegExp } = getGlobUtils();
+		resolveOptions.restrictions = compileRelativeGlobPaths(
+			resolveOptions.restrictions,
+			createPathGlobRegExp
+		);
+	}
+	return resolveOptions;
 };
 
 /**
@@ -112,7 +125,7 @@ module.exports = class ResolverFactory {
 		if (cachedResolver) {
 			return cachedResolver;
 		}
-		const ident = JSON.stringify(resolveOptions);
+		const ident = getResolveOptionsKey(resolveOptions).key;
 		const resolver = typedCaches.stringified.get(ident);
 		if (resolver) {
 			typedCaches.direct.set(resolveOptions, resolver);

package/lib/resolve/getResolveOptionsKey.js

@@ -0,0 +1,59 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import { ResolveOptionsWithDependencyType } from "./ResolverFactory" */
+
+/** @type {WeakMap<EXPECTED_OBJECT | EXPECTED_FUNCTION, number>} */
+const identities = new WeakMap();
+let nextIdentity = 0;
+
+/**
+ * Serializes resolve options into a cache key. Plain JSON values and regular expressions are keyed by content; functions, class instances and `unsafeCache` objects by identity, which holds only within this process.
+ * @param {ResolveOptionsWithDependencyType} options resolve options
+ * @returns {{ key: string, persistent: boolean }} the key, and whether it means the same in another process
+ */
+const getResolveOptionsKey = (options) => {
+	let persistent = true;
+	const key = JSON.stringify(
+		options,
+		/**
+		 * @this {Record<string, unknown>}
+		 * @param {string} name property name
+		 * @param {unknown} value value, after any `toJSON()`
+		 * @returns {unknown} value to serialize
+		 */
+		function replacer(name, value) {
+			// `toJSON()` already ran, so a plugin could pass for plain data
+			value = this[name];
+			if (
+				value === null ||
+				(typeof value !== "object" && typeof value !== "function") ||
+				Array.isArray(value)
+			) {
+				return value;
+			}
+			if (value instanceof RegExp) return { regexp: value.toString() };
+			const prototype = Object.getPrototypeOf(value);
+			if (
+				name !== "unsafeCache" &&
+				(prototype === Object.prototype || prototype === null)
+			) {
+				return value;
+			}
+			let identity = identities.get(value);
+			if (identity === undefined) {
+				identity = nextIdentity++;
+				identities.set(value, identity);
+			}
+			persistent = false;
+			return { identity };
+		}
+	);
+	return { key, persistent };
+};
+
+module.exports = getResolveOptionsKey;