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

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/webpack
 
 | Field | Value |
 |-------|-------|
-| Original | [webpack](https://www.npmjs.com/package/webpack) @ 5.109.2 |
-| Processed | 2026-08-02 |
+| Original | [webpack](https://www.npmjs.com/package/webpack) @ 5.110.3 |
+| Processed | 2026-09-06 |
 | Smoke test | passed |
 | Deps updated | 9 |
 
@@ -24,12 +24,12 @@ npm install @depup/webpack
 |------------|------|-----|
 | @types/estree | ^1.0.8 | ^1.0.9 |
 | acorn | ^8.16.0 | ^8.18.0 |
-| browserslist | ^4.28.1 | ^4.28.7 |
+| browserslist | ^4.28.1 | ^4.28.9 |
 | chrome-trace-event | ^1.0.2 | ^1.0.4 |
 | enhanced-resolve | ^5.24.4 | ^5.24.5 |
-| es-module-lexer | ^2.1.0 | ^2.3.1 |
-| eslint-scope | 5.1.1 | ^9.1.2 |
+| es-module-lexer | ^2.1.0 | ^2.3.2 |
 | events | ^3.2.0 | ^3.3.0 |
+| minimizer-webpack-plugin | ^5.7.0 | ^5.9.0 |
 | tapable | ^2.3.0 | ^2.3.3 |
 
 ---

package/changes.json

@@ -10,7 +10,7 @@
     },
     "browserslist": {
       "from": "^4.28.1",
-      "to": "^4.28.7"
+      "to": "^4.28.9"
     },
     "chrome-trace-event": {
       "from": "^1.0.2",
@@ -22,21 +22,21 @@
     },
     "es-module-lexer": {
       "from": "^2.1.0",
-      "to": "^2.3.1"
-    },
-    "eslint-scope": {
-      "from": "5.1.1",
-      "to": "^9.1.2"
+      "to": "^2.3.2"
     },
     "events": {
       "from": "^3.2.0",
       "to": "^3.3.0"
     },
+    "minimizer-webpack-plugin": {
+      "from": "^5.7.0",
+      "to": "^5.9.0"
+    },
     "tapable": {
       "from": "^2.3.0",
       "to": "^2.3.3"
     }
   },
-  "timestamp": "2026-08-02T00:59:09.770Z",
+  "timestamp": "2026-09-06T01:00:50.036Z",
   "totalUpdated": 9
 }

package/lib/APIPlugin.js

@@ -26,27 +26,106 @@ const {
 } = require("./javascript/JavascriptParserHelpers");
 const ChunkNameRuntimeModule = require("./runtime/ChunkNameRuntimeModule");
 const GetFullHashRuntimeModule = require("./runtime/GetFullHashRuntimeModule");
+const memoize = require("./util/memoize");
+const { forEachRuntime } = require("./util/runtime");
 
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Module").BuildInfo} BuildInfo */
-/** @typedef {import("./javascript/JavascriptModule").JavascriptModuleBuildInfo} JavascriptModuleBuildInfo */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("./javascript/JavascriptParser").Range} Range */
+const getConcatenatedModule = memoize(() =>
+	require("./optimize/ConcatenatedModule")
+);
 
-// Compilations where a module reassigns `__webpack_public_path__` at runtime.
-// A baked analyzable specifier can't reflect that, so those forms fall back.
-/** @type {WeakSet<Compilation>} */
-const runtimePublicPathOverride = new WeakSet();
+/** @import Compiler from "./Compiler" */
+/** @import Module, { BuildInfo } from "./Module" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildInfo
+ * } from "./javascript/JavascriptModule"
+ */
+/** @import Compilation from "./Compilation" */
+/** @import ChunkGraph from "./ChunkGraph" */
+/** @import JavascriptParser, { Range } from "./javascript/JavascriptParser" */
+
+// Modules that reassign `__webpack_public_path__` at runtime, by compilation. A baked
+// analyzable specifier can't reflect that, so those forms fall back. Also recorded per
+// module in `buildInfo`, because a module restored from the persistent cache is never
+// re-parsed and would otherwise lose the flag.
+/** @type {WeakMap<Compilation, Set<Module>>} */
+const runtimePublicPathOverride = new WeakMap();
 
 /**
  * @param {Compilation} compilation compilation
- * @returns {boolean} true when a module reassigns `__webpack_public_path__` at runtime
+ * @param {Module} module the module doing the reassigning
+ * @returns {void}
+ */
+const addRuntimePublicPathOverride = (compilation, module) => {
+	const modules = runtimePublicPathOverride.get(compilation);
+	if (modules === undefined) {
+		runtimePublicPathOverride.set(compilation, new Set([module]));
+	} else {
+		modules.add(module);
+	}
+};
+
+/**
+ * @param {Compilation} compilation compilation
+ * @returns {boolean} true when any module reassigns `__webpack_public_path__` at runtime
  */
 const usesRuntimePublicPathOverride = (compilation) =>
 	runtimePublicPathOverride.has(compilation);
 
+// `__webpack_require__.p` belongs to a runtime, so a reassignment only reaches the
+// runtimes the reassigning module is instantiated in. Computed once the chunk graph
+// can answer that, which is any time code is being generated.
+/** @type {WeakMap<ChunkGraph, Set<string>>} */
+const overriddenRuntimes = new WeakMap();
+
+/**
+ * Whether the public path is reassigned in any runtime `module` belongs to. Falls back
+ * to the whole compilation when there is no chunk graph to place the module in.
+ * @param {Compilation} compilation compilation
+ * @param {ChunkGraph=} chunkGraph the chunk graph
+ * @param {Module=} module the module a reference is emitted into
+ * @returns {boolean} true when a reassignment can reach this module's runtimes
+ */
+const runtimeUsesPublicPathOverride = (compilation, chunkGraph, module) => {
+	const modules = runtimePublicPathOverride.get(compilation);
+	if (modules === undefined) return false;
+	if (chunkGraph === undefined || module === undefined) return true;
+	// Keyed by the chunk graph, not the compilation: `executeModule` asks with a
+	// throw-away one whose answer must not outlive it.
+	let runtimes = overriddenRuntimes.get(chunkGraph);
+	if (runtimes === undefined) {
+		/** @type {Set<string>} */
+		const collected = new Set();
+		const ConcatenatedModule = getConcatenatedModule();
+		for (const overriding of modules) {
+			// Concatenation may have absorbed the reassigning module, and the chunk graph
+			// places only the `ConcatenatedModule` that replaced it.
+			for (const runtime of chunkGraph.getModuleRuntimes(
+				ConcatenatedModule.getChunkGraphModule(compilation, overriding)
+			)) {
+				forEachRuntime(runtime, (key) => {
+					collected.add(/** @type {string} */ (key));
+				});
+			}
+		}
+		runtimes = collected;
+		overriddenRuntimes.set(chunkGraph, collected);
+	}
+	const overridden = runtimes;
+	if (overridden.size === 0) return false;
+	/** @type {Set<string>} */
+	const own = new Set();
+	for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+		forEachRuntime(runtime, (key) => {
+			own.add(/** @type {string} */ (key));
+		});
+	}
+	for (const key of own) {
+		if (overridden.has(key)) return true;
+	}
+	return false;
+};
+
 /**
  * Returns the replacement definitions used for webpack API identifiers.
  * @returns {Record<string, { expr: string, req: string[] | null, type?: string, assign: boolean }>} replacements
@@ -107,6 +186,12 @@ function getReplacements() {
 			type: "string",
 			assign: false
 		},
+		__webpack_css_server_styles__: {
+			expr: `${RuntimeGlobals.getCssServerStyles}()`,
+			req: [RuntimeGlobals.getCssServerStyles],
+			type: "string",
+			assign: false
+		},
 		__webpack_chunkname__: {
 			expr: RuntimeGlobals.chunkName,
 			req: [RuntimeGlobals.chunkName],
@@ -173,6 +258,16 @@ class APIPlugin {
 						"__WEBPACK_EXTERNAL_createRequire_require";
 				}
 
+				// A cached module skips parsing, so replay its recorded override flag.
+				compilation.hooks.stillValidModule.tap(PLUGIN_NAME, (module) => {
+					const buildInfo =
+						/** @type {JavascriptModuleBuildInfo | undefined} */
+						(module.buildInfo);
+					if (buildInfo && buildInfo.usingPublicPathOverride) {
+						addRuntimePublicPathOverride(compilation, module);
+					}
+				});
+
 				compilation.dependencyTemplates.set(
 					ConstDependency,
 					new ConstDependency.Template()
@@ -289,10 +384,19 @@ class APIPlugin {
 								throw err;
 							});
 						} else if (key === "__webpack_public_path__") {
-							// Flag the runtime override (still let the default handler emit
-							// `__webpack_require__.p = …`); returning nothing keeps that path.
-							parser.hooks.assign.for(key).tap(PLUGIN_NAME, () => {
-								runtimePublicPathOverride.add(compilation);
+							// Writing the slot needs the scope it lives on, not the runtime
+							// module computing the value it replaces; a read asks for that.
+							const writePublicPath = toConstantDependency(parser, info.expr, [
+								RuntimeGlobals.requireScope
+							]);
+							parser.hooks.assign.for(key).tap(PLUGIN_NAME, (expr) => {
+								/** @type {JavascriptModuleBuildInfo} */
+								(parser.state.module.buildInfo).usingPublicPathOverride = true;
+								addRuntimePublicPathOverride(compilation, parser.state.module);
+								// A destructuring target is no expression to replace; the read
+								// handler still spells the global, with a read's requirement.
+								if (expr.left.type !== "Identifier") return;
+								return writePublicPath(expr.left);
 							});
 						}
 						if (info.type) {
@@ -413,5 +517,7 @@ class APIPlugin {
 	}
 }
 
+APIPlugin.runtimeUsesPublicPathOverride = runtimeUsesPublicPathOverride;
+APIPlugin.usesRuntimePublicPathOverride = usesRuntimePublicPathOverride;
+
 module.exports = APIPlugin;
-module.exports.usesRuntimePublicPathOverride = usesRuntimePublicPathOverride;

package/lib/AsyncDependenciesBlock.js

@@ -8,13 +8,16 @@
 const DependenciesBlock = require("./DependenciesBlock");
 const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("./util/Hash")} Hash */
+/** @import { ChunkGroupOptions } from "./ChunkGroup" */
+/** @import { DependencyLocation, UpdateHashContext } from "./Dependency" */
+/** @import { EntryOptions } from "./Entrypoint" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "./serialization/ObjectMiddleware"
+ */
+/** @import Hash from "./util/Hash" */
 
 /** @typedef {(ChunkGroupOptions & { entryOptions?: EntryOptions } & { circular?: boolean })} GroupOptions */
 

package/lib/AutomaticPrefetchPlugin.js

@@ -9,7 +9,7 @@ const asyncLib = require("neo-async");
 const NormalModule = require("./NormalModule");
 const PrefetchDependency = require("./dependencies/PrefetchDependency");
 
-/** @typedef {import("./Compiler")} Compiler */
+/** @import Compiler from "./Compiler" */
 
 const PLUGIN_NAME = "AutomaticPrefetchPlugin";
 

package/lib/BannerPlugin.js

@@ -10,12 +10,16 @@ const Compilation = require("./Compilation");
 const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const Template = require("./Template");
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
-/** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */
-/** @typedef {import("./Compilation").PathDataChunk} PathDataChunk */
-/** @typedef {import("./Compiler")} Compiler */
-/** @typedef {import("./Chunk")} Chunk */
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	BannerPluginArgument,
+ * 	BannerPluginOptions
+ * } from "../declarations/plugins/BannerPlugin"
+ */
+/** @import { PathDataChunk } from "./Compilation" */
+/** @import Compiler from "./Compiler" */
+/** @import Chunk from "./Chunk" */
 
 /** @typedef {(data: { hash?: string, chunk: Chunk, filename: string }) => string} BannerFunction */
 

package/lib/CacheFacade.js

@@ -10,10 +10,9 @@ const asyncLib = require("neo-async");
 const getLazyHashedEtag = require("./cache/getLazyHashedEtag");
 const mergeEtags = require("./cache/mergeEtags");
 
-/** @typedef {import("./Cache")} Cache */
-/** @typedef {import("./Cache").Etag} Etag */
-/** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
-/** @typedef {import("./util/Hash").HashFunction} HashFunction */
+/** @import Cache, { Etag } from "./Cache" */
+/** @import { HashableObject } from "./cache/getLazyHashedEtag" */
+/** @import { HashFunction } from "./util/Hash" */
 
 /**
  * Defines the callback cache callback.
@@ -385,6 +384,7 @@ class CacheFacade {
 	}
 }
 
+CacheFacade.ItemCacheFacade = ItemCacheFacade;
+CacheFacade.MultiItemCache = MultiItemCache;
+
 module.exports = CacheFacade;
-module.exports.ItemCacheFacade = ItemCacheFacade;
-module.exports.MultiItemCache = MultiItemCache;

package/lib/Chunk.js

@@ -18,19 +18,22 @@ const {
 const { createArrayToSetDeprecationSet } = require("./util/deprecation");
 const { mergeRuntime } = require("./util/runtime");
 
-/** @typedef {import("./ChunkGraph").ChunkFilterPredicate} ChunkFilterPredicate */
-/** @typedef {import("./ChunkGraph").ChunkSizeOptions} ChunkSizeOptions */
-/** @typedef {import("./ChunkGraph").ModuleFilterPredicate} ModuleFilterPredicate */
-/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Compilation").PathDataChunk} PathDataChunk */
+/**
+ * @import {
+ * 	ChunkFilterPredicate,
+ * 	ChunkSizeOptions,
+ * 	ModuleFilterPredicate,
+ * 	ModuleId
+ * } from "./ChunkGraph"
+ */
+/** @import ChunkGroup from "./ChunkGroup" */
+/** @import { EntryOptions } from "./Entrypoint" */
+/** @import Module from "./Module" */
+/** @import { PathDataChunk } from "./Compilation" */
 /** @typedef {import("./TemplatedPathPlugin").TemplatePathFn<PathDataChunk>} ChunkFilenameTemplateFn */
 /** @typedef {string | ChunkFilenameTemplateFn} ChunkFilenameTemplate */
-/** @typedef {import("./util/Hash")} Hash */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
+/** @import Hash from "./util/Hash" */
+/** @import { RuntimeSpec } from "./util/runtime" */
 
 /** @typedef {string | null} ChunkName */
 /** @typedef {string | number} ChunkId */

package/lib/ChunkGraph.js

@@ -29,23 +29,27 @@ const {
 	runtimeToString
 } = require("./util/runtime");
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Chunk").Chunks} Chunks */
-/** @typedef {import("./Chunk").Entrypoints} Entrypoints */
-/** @typedef {import("./Chunk").ChunkId} ChunkId */
-/** @typedef {import("./ChunkGroup")} ChunkGroup */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").SourceType} SourceType */
-/** @typedef {import("./Module").SourceTypes} SourceTypes */
-/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {import("./util/Hash").HashFunction} HashFunction */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./javascript/JavascriptModule").JavascriptModuleBuildMeta} JavascriptModuleBuildMeta */
+/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
+/** @import Chunk, { Chunks, Entrypoints, ChunkId } from "./Chunk" */
+/** @import ChunkGroup from "./ChunkGroup" */
+/**
+ * @import Module, {
+ * 	SourceType,
+ * 	SourceTypes,
+ * 	ReadOnlyRuntimeRequirements,
+ * 	RuntimeRequirements
+ * } from "./Module"
+ */
+/** @import ModuleGraph from "./ModuleGraph" */
+/** @import { ConnectionState } from "./ModuleGraphConnection" */
+/** @import RuntimeModule from "./RuntimeModule" */
+/** @import { HashFunction } from "./util/Hash" */
+/** @import { RuntimeSpec } from "./util/runtime" */
+/**
+ * @import {
+ * 	JavascriptModuleBuildMeta
+ * } from "./javascript/JavascriptModule"
+ */
 
 /** @type {ReadonlySet<string>} */
 const EMPTY_SET = new Set();
@@ -328,6 +332,11 @@ class ChunkGraph {
 		/** @type {ModuleGraph} */
 		this.moduleGraph = moduleGraph;
 
+		// build-time execution (`Compilation.executeModule`) runs modules in a
+		// CommonJS-style vm wrapper, so templates must not emit ESM-only syntax
+		/** @type {boolean} */
+		this.buildTimeExecution = false;
+
 		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 
@@ -1371,27 +1380,29 @@ class ChunkGraph {
 
 		for (const chunkGroup of chunk.groupsIterable) {
 			if (chunkGroup instanceof Entrypoint) {
+				if (entrypoints.has(chunkGroup)) continue;
+				entrypoints.add(chunkGroup);
+				// `entrypoints` doubles as the visited set: a diamond of `dependOn`
+				// edges would otherwise re-traverse the shared entrypoint per path
 				const queue = [chunkGroup];
-				while (queue.length > 0) {
-					const current = queue.shift();
-					if (current) {
-						entrypoints.add(current);
-
-						let hasChildrenEntrypoint = false;
-						for (const child of current.childrenIterable) {
-							if (child instanceof Entrypoint && child.dependOn(current)) {
-								hasChildrenEntrypoint = true;
-								queue.push(/** @type {Entrypoint} */ (child));
+				for (let i = 0; i < queue.length; i++) {
+					const current = queue[i];
+					let hasChildrenEntrypoint = false;
+					for (const child of current.childrenIterable) {
+						if (child instanceof Entrypoint && child.dependOn(current)) {
+							hasChildrenEntrypoint = true;
+							if (!entrypoints.has(child)) {
+								entrypoints.add(child);
+								queue.push(child);
 							}
 						}
-						// entryChunkB: hasChildrenEntrypoint = true
-						// entryChunkA: dependOn = entryChunkB
-						if (hasChildrenEntrypoint) {
-							const entrypointChunk = current.getEntrypointChunk();
-							if (entrypointChunk !== chunk && !entrypointChunk.hasRuntime()) {
-								// add entryChunkB to set
-								set.add(entrypointChunk);
-							}
+					}
+					// an entrypoint others depend on has to be loaded before them,
+					// unless it is the runtime chunk itself or carries its own runtime
+					if (hasChildrenEntrypoint) {
+						const entrypointChunk = current.getEntrypointChunk();
+						if (entrypointChunk !== chunk && !entrypointChunk.hasRuntime()) {
+							set.add(entrypointChunk);
 						}
 					}
 				}

package/lib/ChunkGroup.js

@@ -13,13 +13,13 @@ const {
 	compareLocations
 } = require("./util/comparators");
 
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-/** @typedef {import("./Entrypoint")} Entrypoint */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
+/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
+/** @import Chunk from "./Chunk" */
+/** @import ChunkGraph from "./ChunkGraph" */
+/** @import { DependencyLocation } from "./Dependency" */
+/** @import Entrypoint from "./Entrypoint" */
+/** @import Module from "./Module" */
+/** @import ModuleGraph from "./ModuleGraph" */
 
 /** @typedef {{ module: Module | null, loc: DependencyLocation, request: string }} OriginRecord */
 

package/lib/ChunkTemplate.js

@@ -6,29 +6,27 @@
 "use strict";
 
 const util = require("util");
-const memoize = require("./util/memoize");
+const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 
-/** @typedef {import("tapable").Tap} Tap */
-/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("./Compilation").Hash} Hash */
-/** @typedef {import("./Compilation").RenderManifestEntry} RenderManifestEntry */
-/** @typedef {import("./Compilation").RenderManifestOptions} RenderManifestOptions */
-/** @typedef {import("./Compilation").Source} Source */
-/** @typedef {import("./ModuleTemplate")} ModuleTemplate */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
+/** @import { Tap } from "tapable" */
+/** @import { Source } from "webpack-sources" */
+/**
+ * @import {
+ * 	OutputNormalizedWithDefaults as OutputOptions
+ * } from "./config/defaults"
+ */
+/** @import Chunk from "./Chunk" */
+/** @import Compilation, { ChunkHashContext } from "./Compilation" */
+/** @import ModuleTemplate from "./ModuleTemplate" */
+/** @import { RenderContext } from "./javascript/JavascriptModulesPlugin" */
+/** @import { RenderManifestEntry, RenderManifestOptions } from "./Template" */
+/** @import Hash from "./util/Hash" */
 /**
  * Defines the if set type used by this module.
  * @template T
  * @typedef {import("tapable").IfSet<T>} IfSet
  */
 
-const getJavascriptModulesPlugin = memoize(() =>
-	require("./javascript/JavascriptModulesPlugin")
-);
-
 // TODO webpack 6 remove this class
 class ChunkTemplate {
 	/**
@@ -69,15 +67,11 @@ class ChunkTemplate {
 					 * @param {(source: Source, moduleTemplate: ModuleTemplate, renderContext: RenderContext) => Source} fn function
 					 */
 					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderChunk.tap(options, (source, renderContext) =>
-								fn(
-									source,
-									compilation.moduleTemplates.javascript,
-									renderContext
-								)
-							);
+						JavascriptModulesPlugin.getCompilationHooks(
+							compilation
+						).renderChunk.tap(options, (source, renderContext) =>
+							fn(source, compilation.moduleTemplates.javascript, renderContext)
+						);
 					},
 					"ChunkTemplate.hooks.modules is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
 					"DEP_WEBPACK_CHUNK_TEMPLATE_MODULES"
@@ -92,15 +86,11 @@ class ChunkTemplate {
 					 * @param {(source: Source, moduleTemplate: ModuleTemplate, renderContext: RenderContext) => Source} fn function
 					 */
 					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.renderChunk.tap(options, (source, renderContext) =>
-								fn(
-									source,
-									compilation.moduleTemplates.javascript,
-									renderContext
-								)
-							);
+						JavascriptModulesPlugin.getCompilationHooks(
+							compilation
+						).renderChunk.tap(options, (source, renderContext) =>
+							fn(source, compilation.moduleTemplates.javascript, renderContext)
+						);
 					},
 					"ChunkTemplate.hooks.render is deprecated (use JavascriptModulesPlugin.getCompilationHooks().renderChunk instead)",
 					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER"
@@ -115,9 +105,9 @@ class ChunkTemplate {
 					 * @param {(source: Source, chunk: Chunk) => Source} fn function
 					 */
 					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.render.tap(options, (source, renderContext) => {
+						JavascriptModulesPlugin.getCompilationHooks(compilation).render.tap(
+							options,
+							(source, renderContext) => {
 								if (
 									renderContext.chunkGraph.getNumberOfEntryModules(
 										renderContext.chunk
@@ -127,7 +117,8 @@ class ChunkTemplate {
 									return source;
 								}
 								return fn(source, renderContext.chunk);
-							});
+							}
+						);
 					},
 					"ChunkTemplate.hooks.renderWithEntry is deprecated (use JavascriptModulesPlugin.getCompilationHooks().render instead)",
 					"DEP_WEBPACK_CHUNK_TEMPLATE_RENDER_WITH_ENTRY"
@@ -157,12 +148,12 @@ class ChunkTemplate {
 					 * @param {(hash: Hash, chunk: Chunk, chunkHashContext: ChunkHashContext) => void} fn function
 					 */
 					(options, fn) => {
-						getJavascriptModulesPlugin()
-							.getCompilationHooks(compilation)
-							.chunkHash.tap(options, (chunk, hash, context) => {
-								if (chunk.hasRuntime()) return;
-								fn(hash, chunk, context);
-							});
+						JavascriptModulesPlugin.getCompilationHooks(
+							compilation
+						).chunkHash.tap(options, (chunk, hash, context) => {
+							if (chunk.hasRuntime()) return;
+							fn(hash, chunk, context);
+						});
 					},
 					"ChunkTemplate.hooks.hashForChunk is deprecated (use JavascriptModulesPlugin.getCompilationHooks().chunkHash instead)",
 					"DEP_WEBPACK_CHUNK_TEMPLATE_HASH_FOR_CHUNK"