webpack 5.109.1 → 5.109.2

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -25,11 +25,21 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.41.0
+	 */
+	linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.41.0
+	 */
+	linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+});
+
 /**
- * Defines the jsonp compilation plugin hooks type used by this module.
- * @typedef {object} JsonpCompilationPluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ * @typedef {ReturnType<typeof createCompilationHooks>} JsonpCompilationPluginHooks
  */
 
 class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
@@ -438,11 +448,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 }
 
 ModuleChunkLoadingRuntimeModule.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {JsonpCompilationPluginHooks} */ ({
-			linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-			linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
-		})
+	createCompilationHooks
 );
 
 module.exports = ModuleChunkLoadingRuntimeModule;

package/lib/html/HtmlModulesPlugin.js

@@ -72,12 +72,36 @@ const { escapeAttribute } = require("./syntax");
  * @property {boolean=} remove set true to delete the whole element
  */
 /** @typedef {{ outputName: string, html: string }} HtmlTransformTagsContext */
+
+const createCompilationHooks = () => ({
+	/**
+	 * Called with the list of extra tags to inject into each page (initially empty) plus the current HTML; push `HtmlTagDescriptor`s and return the list — webpack serializes and places them by `injectTo`. A structured alternative to the string-level `transformHtml` for adding tags; runs before CSP so injected inline tags are hashed.
+	 * @type {AsyncSeriesWaterfallHook<[HtmlTagDescriptor[], HtmlInjectTagsContext]>}
+	 * @since 5.109.0
+	 */
+	injectTags: new AsyncSeriesWaterfallHook(["tags", "context"]),
+	/**
+	 * Called with the page's `<script>`/`<link>`/`<style>`/`<meta>` tags (webpack's own and any injected) as mutable descriptors; mutate `attrs` (add a `nonce`/`data-*`, switch `defer`↔`async`, …), set `remove: true`, or change `injectTo` to move a tag between `<head>` and `<body>`, and webpack rewrites the changed tags. Add new tags with `injectTags` instead.
+	 * @type {AsyncSeriesHook<[HtmlMutableTag[], HtmlTransformTagsContext]>}
+	 * @since 5.109.0
+	 */
+	transformTags: new AsyncSeriesHook(["tags", "context"]),
+	/**
+	 * Called with each emitted page's final HTML (all sentinels resolved) just before it is written; return the (possibly transformed) HTML — e.g. to minify, inject a CSP meta, or rewrite tags.
+	 * @type {AsyncSeriesWaterfallHook<[string, HtmlTransformHtmlContext]>}
+	 * @since 5.109.0
+	 */
+	transformHtml: new AsyncSeriesWaterfallHook(["html", "context"]),
+	/**
+	 * Called once each page's HTML asset has been finalized — a post-emit notification (nothing to return).
+	 * @type {AsyncSeriesHook<[HtmlEmittedContext]>}
+	 * @since 5.109.0
+	 */
+	htmlEmitted: new AsyncSeriesHook(["context"])
+});
+
 /**
- * @typedef {object} HtmlCompilationHooks
- * @property {AsyncSeriesWaterfallHook<[HtmlTagDescriptor[], HtmlInjectTagsContext]>} injectTags called with the list of extra tags to inject into each page (initially empty) plus the current HTML; push `HtmlTagDescriptor`s and return the list — webpack serializes and places them by `injectTo`. A structured alternative to the string-level `transformHtml` for adding tags; runs before CSP so injected inline tags are hashed
- * @property {AsyncSeriesHook<[HtmlMutableTag[], HtmlTransformTagsContext]>} transformTags called with the page's `<script>`/`<link>`/`<style>`/`<meta>` tags (webpack's own and any injected) as mutable descriptors; mutate `attrs` (add a `nonce`/`data-*`, switch `defer`↔`async`, …), set `remove: true`, or change `injectTo` to move a tag between `<head>` and `<body>`, and webpack rewrites the changed tags. Add new tags with `injectTags` instead
- * @property {AsyncSeriesWaterfallHook<[string, HtmlTransformHtmlContext]>} transformHtml called with each emitted page's final HTML (all sentinels resolved) just before it is written; return the (possibly transformed) HTML — e.g. to minify, inject a CSP meta, or rewrite tags
- * @property {AsyncSeriesHook<[HtmlEmittedContext]>} htmlEmitted called once each page's HTML asset has been finalized — a post-emit notification (nothing to return)
+ * @typedef {ReturnType<typeof createCompilationHooks>} HtmlCompilationHooks
  */
 
 const PLUGIN_NAME = "HtmlModulesPlugin";
@@ -1099,13 +1123,7 @@ class HtmlModulesPlugin {
  * @returns {HtmlCompilationHooks} the hooks
  */
 HtmlModulesPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {HtmlCompilationHooks} */ ({
-			injectTags: new AsyncSeriesWaterfallHook(["tags", "context"]),
-			transformTags: new AsyncSeriesHook(["tags", "context"]),
-			transformHtml: new AsyncSeriesWaterfallHook(["html", "context"]),
-			htmlEmitted: new AsyncSeriesHook(["context"])
-		})
+	createCompilationHooks
 );
 
 module.exports = HtmlModulesPlugin;

package/lib/javascript/JavascriptModulesPlugin.js

@@ -330,23 +330,89 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {boolean=} renderInObject render module in object container
  */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>}
+	 */
+	renderModuleContent: new SyncWaterfallHook([
+		"source",
+		"module",
+		"moduleRenderContext"
+	]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>}
+	 */
+	renderModuleContainer: new SyncWaterfallHook([
+		"source",
+		"module",
+		"moduleRenderContext"
+	]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>}
+	 */
+	renderModulePackage: new SyncWaterfallHook([
+		"source",
+		"module",
+		"moduleRenderContext"
+	]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, RenderContext]>}
+	 */
+	render: new SyncWaterfallHook(["source", "renderContext"]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, RenderContext]>}
+	 * @since 5.41.0
+	 */
+	renderContent: new SyncWaterfallHook(["source", "renderContext"]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, StartupRenderContext]>}
+	 * @since 5.22.0
+	 */
+	renderStartup: new SyncWaterfallHook([
+		"source",
+		"module",
+		"startupRenderContext"
+	]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, RenderContext]>}
+	 */
+	renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
+	/**
+	 * @type {SyncWaterfallHook<[Source, RenderContext]>}
+	 */
+	renderMain: new SyncWaterfallHook(["source", "renderContext"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, RenderBootstrapContext]>}
+	 */
+	renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
+	/**
+	 * @type {SyncBailHook<[Module, Partial<RenderBootstrapContext>], string | void>}
+	 * @since 5.22.0
+	 */
+	inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+	/**
+	 * @type {SyncBailHook<[Module, RenderContext], string | void>}
+	 * @since 5.22.0
+	 */
+	embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
+	/**
+	 * @type {SyncBailHook<[RenderContext], string | void>}
+	 * @since 5.26.1
+	 */
+	strictRuntimeBailout: new SyncBailHook(["renderContext"]),
+	/**
+	 * @type {SyncHook<[Chunk, Hash, ChunkHashContext]>}
+	 */
+	chunkHash: new SyncHook(["chunk", "hash", "context"]),
+	/**
+	 * @type {SyncBailHook<[Chunk, RenderContext], boolean | void>}
+	 * @since 5.2.1
+	 */
+	useSourceMap: new SyncBailHook(["chunk", "renderContext"])
+});
+
 /**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContent
- * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModuleContainer
- * @property {SyncWaterfallHook<[Source, Module, ModuleRenderContext]>} renderModulePackage
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
- * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
- * @property {SyncWaterfallHook<[Source, RenderContext]>} render
- * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
- * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
- * @property {SyncBailHook<[Module, Partial<RenderBootstrapContext>], string | void>} inlineInRuntimeBailout
- * @property {SyncBailHook<[Module, RenderContext], string | void>} embedInRuntimeBailout
- * @property {SyncBailHook<[RenderContext], string | void>} strictRuntimeBailout
- * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
- * @property {SyncBailHook<[Chunk, RenderContext], boolean | void>} useSourceMap
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
  */
 
 /**
@@ -2288,39 +2354,7 @@ class JavascriptModulesPlugin {
 }
 
 JavascriptModulesPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			renderModuleContent: new SyncWaterfallHook([
-				"source",
-				"module",
-				"moduleRenderContext"
-			]),
-			renderModuleContainer: new SyncWaterfallHook([
-				"source",
-				"module",
-				"moduleRenderContext"
-			]),
-			renderModulePackage: new SyncWaterfallHook([
-				"source",
-				"module",
-				"moduleRenderContext"
-			]),
-			render: new SyncWaterfallHook(["source", "renderContext"]),
-			renderContent: new SyncWaterfallHook(["source", "renderContext"]),
-			renderStartup: new SyncWaterfallHook([
-				"source",
-				"module",
-				"startupRenderContext"
-			]),
-			renderChunk: new SyncWaterfallHook(["source", "renderContext"]),
-			renderMain: new SyncWaterfallHook(["source", "renderContext"]),
-			renderRequire: new SyncWaterfallHook(["code", "renderContext"]),
-			inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-			embedInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-			strictRuntimeBailout: new SyncBailHook(["renderContext"]),
-			chunkHash: new SyncHook(["chunk", "hash", "context"]),
-			useSourceMap: new SyncBailHook(["chunk", "renderContext"])
-		})
+	createCompilationHooks
 );
 
 module.exports = JavascriptModulesPlugin;

package/lib/javascript/JavascriptParser.js

@@ -514,11 +514,17 @@ class JavascriptParser extends Parser {
 			evaluateDefinedIdentifier: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[NewExpression], BasicEvaluatedExpression | null | undefined>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[NewExpression], BasicEvaluatedExpression | null | undefined>>}
+			 * @since 5.73.0
+			 */
 			evaluateNewExpression: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[CallExpression], BasicEvaluatedExpression | null | undefined>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[CallExpression], BasicEvaluatedExpression | null | undefined>>}
+			 * @since 5.73.0
+			 */
 			evaluateCallExpression: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
@@ -532,12 +538,18 @@ class JavascriptParser extends Parser {
 			),
 			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
 			preStatement: new SyncBailHook(["statement"]),
-			/** @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>}
+			 * @since 5.109.0
+			 */
 			preStatementByType: new HookMap(() => new SyncBailHook(["statement"])),
 
 			/** @type {SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>} */
 			blockPreStatement: new SyncBailHook(["declaration"]),
-			/** @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[Statement | ModuleDeclaration | MaybeNamedClassDeclaration | MaybeNamedFunctionDeclaration], boolean | void>>}
+			 * @since 5.109.0
+			 */
 			blockPreStatementByType: new HookMap(
 				() => new SyncBailHook(["declaration"])
 			),
@@ -545,7 +557,10 @@ class JavascriptParser extends Parser {
 			statement: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[IfStatement], boolean | void>} */
 			statementIf: new SyncBailHook(["statement"]),
-			/** @type {SyncBailHook<[Expression], GuardCollection | void>} */
+			/**
+			 * @type {SyncBailHook<[Expression], GuardCollection | void>}
+			 * @since 5.105.0
+			 */
 			collectGuards: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Expression, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classExtendsExpression: new SyncBailHook([
@@ -554,7 +569,10 @@ class JavascriptParser extends Parser {
 			]),
 			/** @type {SyncBailHook<[MethodDefinition | PropertyDefinition | StaticBlock, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
 			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
-			/** @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>} */
+			/**
+			 * @type {SyncBailHook<[Expression, MethodDefinition | PropertyDefinition, ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration], boolean | void>}
+			 * @since 5.36.0
+			 */
 			classBodyValue: new SyncBailHook([
 				"expression",
 				"element",
@@ -604,13 +622,19 @@ class JavascriptParser extends Parser {
 			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
 			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
-			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
+			/**
+			 * @type {HookMap<SyncBailHook<[Identifier], boolean | void>>}
+			 * @since 5.100.0
+			 */
 			varDeclarationUsing: new HookMap(() => new SyncBailHook(["declaration"])),
 			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
 			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
-			/** @type {SyncBailHook<[Expression], boolean | void>} */
+			/**
+			 * @type {SyncBailHook<[Expression], boolean | void>}
+			 * @since 5.101.3
+			 */
 			collectDestructuringAssignmentProperties: new SyncBailHook([
 				"expression"
 			]),
@@ -671,7 +695,10 @@ class JavascriptParser extends Parser {
 			optionalChaining: new SyncBailHook(["optionalChaining"]),
 			/** @type {HookMap<SyncBailHook<[NewExpression], boolean | void>>} */
 			new: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {SyncBailHook<[BinaryExpression], boolean | void>} */
+			/**
+			 * @type {SyncBailHook<[BinaryExpression], boolean | void>}
+			 * @since 5.71.0
+			 */
 			binaryExpression: new SyncBailHook(["binaryExpression"]),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			expression: new HookMap(() => new SyncBailHook(["expression"])),
@@ -695,11 +722,17 @@ class JavascriptParser extends Parser {
 			expressionLogicalOperator: new SyncBailHook(["expression"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			program: new SyncBailHook(["ast", "comments"]),
-			/** @type {SyncBailHook<[ThrowStatement | ReturnStatement], boolean | void>} */
+			/**
+			 * @type {SyncBailHook<[ThrowStatement | ReturnStatement], boolean | void>}
+			 * @since 5.99.0
+			 */
 			terminate: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[Program, Comment[]], boolean | void>} */
 			finish: new SyncBailHook(["ast", "comments"]),
-			/** @type {SyncBailHook<[Statement], boolean | void>} */
+			/**
+			 * @type {SyncBailHook<[Statement], boolean | void>}
+			 * @since 5.99.9
+			 */
 			unusedStatement: new SyncBailHook(["statement"])
 		});
 		this.sourceType = sourceType;

package/lib/optimize/RealContentHashPlugin.js

@@ -166,10 +166,16 @@ const toCachedSource = (source) => {
  * @property {Hashes} hashes
  */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncBailHook<[Buffer[], string], string | void>}
+	 * @since 5.8.0
+	 */
+	updateHash: new SyncBailHook(["content", "oldHash"])
+});
+
 /**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncBailHook<[Buffer[], string], string | void>} updateHash
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
  */
 
 /**
@@ -554,10 +560,7 @@ ${referencingAssets
 }
 
 RealContentHashPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			updateHash: new SyncBailHook(["content", "oldHash"])
-		})
+	createCompilationHooks
 );
 
 module.exports = RealContentHashPlugin;