webpack 5.108.1 → 5.108.3

package/lib/CleanPlugin.js

@@ -8,7 +8,7 @@
 const path = require("path");
 const asyncLib = require("neo-async");
 const { SyncBailHook } = require("tapable");
-const Compilation = require("./Compilation");
+const createHooksRegistry = require("./util/createHooksRegistry");
 const { join } = require("./util/fs");
 const { ABSOLUTE_PATH_REGEXP } = require("./util/identifier");
 const processAsyncTree = require("./util/processAsyncTree");
@@ -335,33 +335,9 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 	);
 };
 
-/** @type {WeakMap<Compilation, CleanPluginCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
 const PLUGIN_NAME = "CleanPlugin";
 
 class CleanPlugin {
-	/**
-	 * Returns the attached hooks.
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CleanPluginCompilationHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				keep: new SyncBailHook(["ignore"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/** @param {CleanOptions} options options */
 	constructor(options = {}) {
 		/** @type {CleanOptions} */
@@ -508,5 +484,12 @@ class CleanPlugin {
 	}
 }
 
+CleanPlugin.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {CleanPluginCompilationHooks} */ ({
+			keep: new SyncBailHook(["ignore"])
+		})
+);
+
 module.exports = CleanPlugin;
 module.exports._getDirectories = getDirectories;

package/lib/Compilation.js

@@ -2377,7 +2377,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					applyFactoryResultDependencies();
 					return callback();
 				}
-
 				if (currentProfile !== undefined) {
 					moduleGraph.setProfile(newModule, currentProfile);
 				}

package/lib/DefinePlugin.js

@@ -21,6 +21,7 @@ const {
 	toConstantDependency
 } = require("./javascript/JavascriptParserHelpers");
 const createHash = require("./util/createHash");
+const createHooksRegistry = require("./util/createHooksRegistry");
 
 /** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("./Compiler")} Compiler */
@@ -362,26 +363,7 @@ const WEBPACK_REQUIRE_IDENTIFIER_REGEXP = new RegExp(RuntimeGlobals.require);
 
 /** @typedef {Record<string, CodeValue>} Definitions */
 
-/** @type {WeakMap<Compilation, DefinePluginHooks>} */
-const compilationHooksMap = new WeakMap();
-
 class DefinePlugin {
-	/**
-	 * Returns the attached hooks.
-	 * @param {Compilation} compilation the compilation
-	 * @returns {DefinePluginHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				definitions: new SyncWaterfallHook(["definitions"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/**
 	 * Create a new define plugin
 	 * @param {Definitions} definitions A map of global object definitions
@@ -962,4 +944,11 @@ class DefinePlugin {
 	}
 }
 
+DefinePlugin.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {DefinePluginHooks} */ ({
+			definitions: new SyncWaterfallHook(["definitions"])
+		})
+);
+
 module.exports = DefinePlugin;

package/lib/ExternalModule.js

@@ -25,7 +25,9 @@ const { DEFAULTS } = require("./config/defaults");
 const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
 const EnvironmentNotSupportAsyncWarning = require("./errors/EnvironmentNotSupportAsyncWarning");
+const { coreModules } = require("./node/nodeBuiltins");
 const createHash = require("./util/createHash");
+const createHooksRegistry = require("./util/createHooksRegistry");
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
 const makeSerializable = require("./util/makeSerializable");
 const { propertyAccess } = require("./util/property");
@@ -101,6 +103,56 @@ const RUNTIME_REQUIREMENTS_FOR_MODULE = new Set([
 /** @type {RuntimeRequirements} */
 const EMPTY_RUNTIME_REQUIREMENTS = new Set();
 
+const NODE_PREFIX = "node:";
+// External types that emit a node.js-resolvable specifier (`require`/`import`).
+const NODE_RESOLVING_EXTERNAL_TYPES = new Set([
+	"commonjs",
+	"commonjs2",
+	"commonjs-module",
+	"commonjs-static",
+	"node-commonjs",
+	"import",
+	"module"
+]);
+
+/**
+ * Normalizes a node.js core module specifier for the target. Strips `node:`
+ * when the target can't resolve a prefixed request, adds `node:` for a universal
+ * bundle (which may run on deno/bun where the prefix is required), and otherwise
+ * keeps the author's original notation.
+ * @param {string | string[]} request the external request
+ * @param {ExternalsType} externalType the resolved external type
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @returns {string | string[]} the normalized request
+ */
+const normalizeNodeCoreModuleRequest = (
+	request,
+	externalType,
+	runtimeTemplate
+) => {
+	if (!NODE_RESOLVING_EXTERNAL_TYPES.has(externalType)) return request;
+	const name = Array.isArray(request) ? request[0] : request;
+	if (typeof name !== "string") return request;
+	/**
+	 * @param {string} next replacement specifier
+	 * @returns {string | string[]} request with the specifier swapped
+	 */
+	const withName = (next) =>
+		Array.isArray(request) ? [next, ...request.slice(1)] : next;
+
+	if (
+		runtimeTemplate.outputOptions.environment.nodePrefixForCoreModules === false
+	) {
+		if (!name.startsWith(NODE_PREFIX)) return request;
+		const stripped = name.slice(NODE_PREFIX.length);
+		return coreModules.has(stripped) ? withName(stripped) : request;
+	}
+	if (runtimeTemplate.isUniversalTarget() && !name.startsWith(NODE_PREFIX)) {
+		return coreModules.has(name) ? withName(NODE_PREFIX + name) : request;
+	}
+	return request;
+};
+
 /**
  * Gets source for global variable external.
  * @param {string | string[]} variableName the variable name or path
@@ -716,9 +768,6 @@ const getSourceForDefaultCase = (optional, request, runtimeTemplate) => {
  * @property {SyncBailHook<[Chunk, Compilation], boolean>} chunkCondition
  */
 
-/** @type {WeakMap<Compilation, ExternalModuleHooks>} */
-const compilationHooksMap = new WeakMap();
-
 /**
  * Defines the build info properties specific to external modules.
  * @typedef {object} KnownExternalModuleBuildInfo
@@ -753,22 +802,6 @@ class ExternalModule extends Module {
 		this.dependencyMeta = dependencyMeta;
 	}
 
-	/**
-	 * Returns the attached hooks.
-	 * @param {Compilation} compilation the compilation
-	 * @returns {ExternalModuleHooks} the attached hooks
-	 */
-	static getCompilationHooks(compilation) {
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				chunkCondition: new SyncBailHook(["chunk", "compilation"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/**
 	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
@@ -1042,6 +1075,11 @@ class ExternalModule extends Module {
 		dependencyMeta,
 		concatenationScope
 	) {
+		request = normalizeNodeCoreModuleRequest(
+			request,
+			externalType,
+			runtimeTemplate
+		);
 		switch (externalType) {
 			case "this":
 			case "window":
@@ -1345,6 +1383,13 @@ class ExternalModule extends Module {
 	}
 }
 
+ExternalModule.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {ExternalModuleHooks} */ ({
+			chunkCondition: new SyncBailHook(["chunk", "compilation"])
+		})
+);
+
 makeSerializable(ExternalModule, "webpack/lib/ExternalModule");
 
 module.exports = ExternalModule;

package/lib/ExternalModuleFactoryPlugin.js

@@ -13,6 +13,7 @@ const CssImportDependency = require("./dependencies/CssImportDependency");
 const CssUrlDependency = require("./dependencies/CssUrlDependency");
 const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
 const ImportDependency = require("./dependencies/ImportDependency");
+const { coreModules } = require("./node/nodeBuiltins");
 const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 
 /** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
@@ -48,6 +49,21 @@ const { cachedSetProperty, resolveByProperty } = require("./util/cleverMerge");
 
 const UNSPECIFIED_EXTERNAL_TYPE_REGEXP = /^[a-z0-9-]+ /;
 const EMPTY_RESOLVE_OPTIONS = {};
+const NODE_PREFIX = "node:";
+
+/**
+ * For a node.js core module request, returns its `node:`-prefixed/unprefixed
+ * counterpart so externals match regardless of which form the code uses.
+ * @param {string} request the request as written in the import/require
+ * @returns {string | undefined} the alternate form, or undefined when not a core module
+ */
+const getAlternateCoreModuleRequest = (request) => {
+	if (request.startsWith(NODE_PREFIX)) {
+		const name = request.slice(NODE_PREFIX.length);
+		return coreModules.has(name) ? name : undefined;
+	}
+	return coreModules.has(request) ? NODE_PREFIX + request : undefined;
+};
 
 // TODO webpack 6 remove this
 const callDeprecatedExternals = util.deprecate(
@@ -236,7 +252,10 @@ class ExternalModuleFactoryPlugin {
 				 */
 				const handleExternals = (externals, callback) => {
 					if (typeof externals === "string") {
-						if (externals === dependency.request) {
+						if (
+							externals === dependency.request ||
+							externals === getAlternateCoreModuleRequest(dependency.request)
+						) {
 							return handleExternal(dependency.request, undefined, callback);
 						}
 					} else if (Array.isArray(externals)) {
@@ -374,6 +393,23 @@ class ExternalModuleFactoryPlugin {
 								callback
 							);
 						}
+						// Fall back to the `node:`-prefixed/unprefixed core module form.
+						const alternateRequest = getAlternateCoreModuleRequest(
+							dependency.request
+						);
+						if (
+							alternateRequest !== undefined &&
+							Object.prototype.hasOwnProperty.call(
+								resolvedExternals,
+								alternateRequest
+							)
+						) {
+							return handleExternal(
+								resolvedExternals[alternateRequest],
+								undefined,
+								callback
+							);
+						}
 					}
 					callback();
 				};

package/lib/LazyBarrel.js

@@ -73,7 +73,7 @@ class LazyBarrelInfo {
 	}
 
 	/**
-	 * Defers a dependency under its request key.
+	 * Records a deferred dependency under its request key.
 	 * @param {string} requestKey request key
 	 * @param {Dependency} dependency dependency to defer
 	 * @param {ModuleFactory} factory factory for the request
@@ -86,7 +86,6 @@ class LazyBarrelInfo {
 			this._requestToDepGroup.set(requestKey, group);
 		}
 		group.dependencies.push(dependency);
-		dependency.setLazy(true);
 	}
 
 	/**
@@ -251,7 +250,9 @@ class LazyBarrelController {
 					? resourceIdent
 					: `${category}${resourceIdent}`;
 			if (info === undefined) info = new LazyBarrelInfo();
-			info.addLazy(requestKey, dep, factory, dep.getContext());
+			if (dep.isLazy()) {
+				info.addLazy(requestKey, dep, factory, dep.getContext());
+			}
 			if (until === Dependency.LAZY_UNTIL_ID) {
 				info.addForwardId(
 					/** @type {string} */ (dep.getLazyName()),

package/lib/NormalModule.js

@@ -19,7 +19,6 @@ const {
 	RawSource,
 	SourceMapSource
 } = require("webpack-sources");
-const Compilation = require("./Compilation");
 const Dependency = require("./Dependency");
 const Module = require("./Module");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
@@ -41,6 +40,7 @@ const {
 	sortWithSourceOrder
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
+const createHooksRegistry = require("./util/createHooksRegistry");
 const { createFakeHook } = require("./util/deprecation");
 const formatLocation = require("./util/formatLocation");
 const { join } = require("./util/fs");
@@ -60,6 +60,7 @@ const parseJson = require("./util/parseJson");
 /** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */
+/** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./Generator")} Generator */
@@ -762,8 +763,52 @@ const asBuffer = (input) => {
 
 /** @typedef {BuildInfo & KnownNormalModuleBuildInfo} NormalModuleBuildInfo */
 
-/** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+const normalModuleHooksRegistry = createHooksRegistry(() => {
+	// TODO webpack 6 deprecate
+	/** @type {Partial<NormalModuleCompilationHooks>} */
+	const hooks = {};
+	hooks.readResourceForScheme = new HookMap((scheme) => {
+		const hook =
+			/** @type {NormalModuleCompilationHooks} */
+			(hooks).readResource.for(scheme);
+		return createFakeHook(
+			/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
+				tap: (options, fn) =>
+					hook.tap(options, (loaderContext) =>
+						fn(
+							loaderContext.resource,
+							/** @type {NormalModule} */ (loaderContext._module)
+						)
+					),
+				tapAsync: (options, fn) =>
+					hook.tapAsync(options, (loaderContext, callback) =>
+						fn(
+							loaderContext.resource,
+							/** @type {NormalModule} */ (loaderContext._module),
+							callback
+						)
+					),
+				tapPromise: (options, fn) =>
+					hook.tapPromise(options, (loaderContext) =>
+						fn(
+							loaderContext.resource,
+							/** @type {NormalModule} */ (loaderContext._module)
+						)
+					)
+			})
+		);
+	});
+	hooks.readResource = new HookMap(
+		() => new AsyncSeriesBailHook(["loaderContext"])
+	);
+	hooks.loader = new SyncHook(["loaderContext", "module"]);
+	hooks.beforeLoaders = new SyncHook(["loaders", "module", "loaderContext"]);
+	hooks.beforeParse = new SyncHook(["module"]);
+	hooks.beforeSnapshot = new SyncHook(["module"]);
+	hooks.processResult = new SyncWaterfallHook(["result", "module"]);
+	hooks.needBuild = new AsyncSeriesBailHook(["module", "context"]);
+	return /** @type {NormalModuleCompilationHooks} */ (hooks);
+});
 
 class NormalModule extends Module {
 	/**
@@ -771,62 +816,7 @@ class NormalModule extends Module {
 	 * @returns {NormalModuleCompilationHooks} the attached hooks
 	 */
 	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				loader: new SyncHook(["loaderContext", "module"]),
-				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-				beforeParse: new SyncHook(["module"]),
-				beforeSnapshot: new SyncHook(["module"]),
-				// TODO webpack 6 deprecate
-				readResourceForScheme: new HookMap((scheme) => {
-					const hook =
-						/** @type {NormalModuleCompilationHooks} */
-						(hooks).readResource.for(scheme);
-					return createFakeHook(
-						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
-							tap: (options, fn) =>
-								hook.tap(options, (loaderContext) =>
-									fn(
-										loaderContext.resource,
-										/** @type {NormalModule} */ (loaderContext._module)
-									)
-								),
-							tapAsync: (options, fn) =>
-								hook.tapAsync(options, (loaderContext, callback) =>
-									fn(
-										loaderContext.resource,
-										/** @type {NormalModule} */ (loaderContext._module),
-										callback
-									)
-								),
-							tapPromise: (options, fn) =>
-								hook.tapPromise(options, (loaderContext) =>
-									fn(
-										loaderContext.resource,
-										/** @type {NormalModule} */ (loaderContext._module)
-									)
-								)
-						})
-					);
-				}),
-				readResource: new HookMap(
-					() => new AsyncSeriesBailHook(["loaderContext"])
-				),
-				processResult: new SyncWaterfallHook(["result", "module"]),
-				needBuild: new AsyncSeriesBailHook(["module", "context"])
-			};
-			compilationHooksMap.set(
-				compilation,
-				/** @type {NormalModuleCompilationHooks} */ (hooks)
-			);
-		}
-		return /** @type {NormalModuleCompilationHooks} */ (hooks);
+		return normalModuleHooksRegistry(compilation);
 	}
 
 	/**

package/lib/bun/BunTargetPlugin.js

@@ -6,18 +6,12 @@
 "use strict";
 
 const ExternalsPlugin = require("../ExternalsPlugin");
-const NodeTargetPlugin = require("../node/NodeTargetPlugin");
+const { coreModules } = require("../node/nodeBuiltins");
 
 /** @typedef {import("../Compiler")} Compiler */
 
 // Bun exposes the node.js core modules; externalize them with the `node:`
 // specifier (Bun resolves both forms) like the deno target.
-// cspell:word pnpapi
-const coreModules = new Set(
-	NodeTargetPlugin.builtins.filter(
-		(builtin) => typeof builtin === "string" && builtin !== "pnpapi"
-	)
-);
 
 // Bun's own built-in modules (`bun`, `bun:sqlite`, ...) are provided by the
 // runtime, never bundled.

package/lib/container/ModuleFederationPlugin.js

@@ -7,8 +7,8 @@
 
 const { SyncHook } = require("tapable");
 const isValidExternalsType = require("../../schemas/plugins/container/ExternalsType.check");
-const Compilation = require("../Compilation");
 const SharePlugin = require("../sharing/SharePlugin");
+const createHooksRegistry = require("../util/createHooksRegistry");
 const ContainerPlugin = require("./ContainerPlugin");
 const ContainerReferencePlugin = require("./ContainerReferencePlugin");
 const HoistContainerReferences = require("./HoistContainerReferencesPlugin");
@@ -25,8 +25,6 @@ const HoistContainerReferences = require("./HoistContainerReferencesPlugin");
  * @property {SyncHook<Dependency>} addFederationRuntimeDependency
  */
 
-/** @type {WeakMap<Compilation, CompilationHooks>} */
-const compilationHooksMap = new WeakMap();
 const PLUGIN_NAME = "ModuleFederationPlugin";
 
 class ModuleFederationPlugin {
@@ -39,28 +37,6 @@ class ModuleFederationPlugin {
 		this.options = options;
 	}
 
-	/**
-	 * Get the compilation hooks associated with this plugin.
-	 * @param {Compilation} compilation The compilation instance.
-	 * @returns {CompilationHooks} The hooks for the compilation.
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (!hooks) {
-			hooks = {
-				addContainerEntryDependency: new SyncHook(["dependency"]),
-				addFederationRuntimeDependency: new SyncHook(["dependency"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
@@ -134,4 +110,12 @@ class ModuleFederationPlugin {
 	}
 }
 
+ModuleFederationPlugin.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {CompilationHooks} */ ({
+			addContainerEntryDependency: new SyncHook(["dependency"]),
+			addFederationRuntimeDependency: new SyncHook(["dependency"])
+		})
+);
+
 module.exports = ModuleFederationPlugin;

package/lib/css/CssInjectStyleRuntimeModule.js

@@ -6,10 +6,11 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
-const Compilation = require("../Compilation");
+/** @typedef {import("../Compilation")} Compilation */
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const createHooksRegistry = require("../util/createHooksRegistry");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
@@ -19,30 +20,7 @@ const Template = require("../Template");
  * @property {SyncWaterfallHook<[string, Chunk]>} createStyle
  */
 
-/** @type {WeakMap<Compilation, CssInjectCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
-
 class CssInjectStyleRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CssInjectCompilationHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				createStyle: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/**
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
@@ -207,4 +185,11 @@ class CssInjectStyleRuntimeModule extends RuntimeModule {
 	}
 }
 
+CssInjectStyleRuntimeModule.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {CssInjectCompilationHooks} */ ({
+			createStyle: new SyncWaterfallHook(["source", "chunk"])
+		})
+);
+
 module.exports = CssInjectStyleRuntimeModule;

package/lib/css/CssLoadingRuntimeModule.js

@@ -6,12 +6,13 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
-const Compilation = require("../Compilation");
+/** @typedef {import("../Compilation")} Compilation */
 const { CSS_TYPE } = require("../ModuleSourceTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
+const createHooksRegistry = require("../util/createHooksRegistry");
 const { chunkHasCss } = require("./CssModulesPlugin");
 
 /** @typedef {import("../Chunk")} Chunk */
@@ -27,33 +28,7 @@ const { chunkHasCss } = require("./CssModulesPlugin");
  * @property {SyncWaterfallHook<[string, Chunk]>} linkInsert
  */
 
-/** @type {WeakMap<Compilation, CssLoadingRuntimeModulePluginHooks>} */
-const compilationHooksMap = new WeakMap();
-
 class CssLoadingRuntimeModule extends RuntimeModule {
-	/**
-	 * @param {Compilation} compilation the compilation
-	 * @returns {CssLoadingRuntimeModulePluginHooks} hooks
-	 */
-	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				createStylesheet: new SyncWaterfallHook(["source", "chunk"]),
-				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-				linkPrefetch: new SyncWaterfallHook(["source", "chunk"]),
-				linkInsert: new SyncWaterfallHook(["source", "chunk"])
-			};
-			compilationHooksMap.set(compilation, hooks);
-		}
-		return hooks;
-	}
-
 	/**
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
@@ -597,4 +572,14 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 	}
 }
 
+CssLoadingRuntimeModule.getCompilationHooks = createHooksRegistry(
+	() =>
+		/** @type {CssLoadingRuntimeModulePluginHooks} */ ({
+			createStylesheet: new SyncWaterfallHook(["source", "chunk"]),
+			linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+			linkPrefetch: new SyncWaterfallHook(["source", "chunk"]),
+			linkInsert: new SyncWaterfallHook(["source", "chunk"])
+		})
+);
+
 module.exports = CssLoadingRuntimeModule;