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

package/lib/optimize/InnerGraphPlugin.js

@@ -9,9 +9,15 @@ const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const {
+	harmonySpecifierTag
+} = require("../dependencies/HarmonyImportDependencyParserPlugin");
+const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
 const PureExpressionDependency = require("../dependencies/PureExpressionDependency");
-const InnerGraph = require("./InnerGraph");
+const { getInnerGraphUtils, topLevelSymbolTag } = require("./InnerGraph");
 
+/** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
 /** @typedef {import("estree").ClassExpression} ClassExpression */
 /** @typedef {import("estree").Expression} Expression */
@@ -20,19 +26,22 @@ const InnerGraph = require("./InnerGraph");
 /** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 /** @typedef {import("./InnerGraph").TopLevelSymbol} TopLevelSymbol */
 
-const { topLevelSymbolTag } = InnerGraph;
-
 const PLUGIN_NAME = "InnerGraphPlugin";
+const impureVariableDeclarationKinds = new Set(["using", "await using"]);
 
 class InnerGraphPlugin {
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -41,6 +50,7 @@ class InnerGraphPlugin {
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const logger = compilation.getLogger("webpack.InnerGraphPlugin");
+				const innerGraph = getInnerGraphUtils(compilation);
 
 				compilation.dependencyTemplates.set(
 					PureExpressionDependency,
@@ -48,16 +58,32 @@ class InnerGraphPlugin {
 				);
 
 				/**
+				 * Adds pure dependency added after parsing, with parents set so it survives persistent caching.
+				 * @param {Module} module module
+				 * @param {Dependency} dep pure dependency
+				 * @returns {void}
+				 */
+				const addPureDependency = (module, dep) => {
+					compilation.moduleGraph.setParents(dep, module, module, -1);
+					module.addDependency(dep);
+				};
+
+				/**
+				 * Handles the hook callback for this code path.
 				 * @param {JavascriptParser} parser the parser
 				 * @param {JavascriptParserOptions} parserOptions options
 				 * @returns {void}
 				 */
 				const handler = (parser, parserOptions) => {
 					/**
+					 * Processes the provided sup.
 					 * @param {Expression} sup sup
 					 */
 					const onUsageSuper = (sup) => {
-						InnerGraph.onUsage(parser.state, (usedByExports) => {
+						// the callback fires after parsing, when the parser can no
+						// longer map offsets — take the location now
+						const loc = parser.getLocation(sup);
+						innerGraph.onUsage(parser.state, (usedByExports, module) => {
 							switch (usedByExports) {
 								case undefined:
 								case true:
@@ -67,9 +93,9 @@ class InnerGraphPlugin {
 										/** @type {Range} */
 										(sup.range)
 									);
-									dep.loc = /** @type {DependencyLocation} */ (sup.loc);
+									dep.loc = loc;
 									dep.usedByExports = usedByExports;
-									parser.state.module.addDependency(dep);
+									addPureDependency(module, dep);
 									break;
 								}
 							}
@@ -77,21 +103,14 @@ class InnerGraphPlugin {
 					};
 
 					parser.hooks.program.tap(PLUGIN_NAME, () => {
-						InnerGraph.enable(parser.state);
+						innerGraph.enable(parser.state);
 
 						statementWithTopLevelSymbol = new WeakMap();
 						statementPurePart = new WeakMap();
 						classWithTopLevelSymbol = new WeakMap();
 						declWithTopLevelSymbol = new WeakMap();
 						pureDeclarators = new WeakSet();
-					});
-
-					parser.hooks.finish.tap(PLUGIN_NAME, () => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
-
-						logger.time("infer dependency usage");
-						InnerGraph.inferDependencyUsage(parser.state);
-						logger.timeAggregate("infer dependency usage");
+						pureConditionByCallExpr = new WeakMap();
 					});
 
 					// During prewalking the following datastructures are filled with
@@ -116,75 +135,157 @@ class InnerGraphPlugin {
 					/** @type {WeakSet<VariableDeclarator>} */
 					let pureDeclarators = new WeakSet();
 
+					/** @type {WeakMap<CallExpression, (compilation: Compilation, module: Module) => boolean>} */
+					let pureConditionByCallExpr = new WeakMap();
+
+					parser.hooks.isPure.for("CallExpression").tap(
+						{
+							name: PLUGIN_NAME,
+							stage: -10
+						},
+						(expression) => {
+							const expr = /** @type {CallExpression} */ (expression);
+							const callee = expr.callee;
+							/** @type {Node} */
+							let root;
+							/** @type {string[]} */
+							let chainMembers;
+							if (callee.type === "Identifier") {
+								root = callee;
+								chainMembers = [];
+							} else if (callee.type === "MemberExpression") {
+								const chain = parser.extractMemberExpressionChain(callee);
+								// optional chaining short-circuits and breaks straight purity
+								if (chain.membersOptionals.some(Boolean)) return;
+								root = /** @type {Node} */ (chain.object);
+								// extractMemberExpressionChain returns members in reverse
+								chainMembers = [...chain.members].reverse();
+							} else {
+								return;
+							}
+							if (root.type !== "Identifier") return;
+							const harmonySettings =
+								/** @type {{ source: string, ids: string[] } | undefined} */ (
+									parser.getTagData(root.name, harmonySpecifierTag)
+								);
+							if (!harmonySettings) return;
+							const ids = [...harmonySettings.ids, ...chainMembers];
+							if (ids.length === 0) return;
+							let pos = /** @type {Range} */ (callee.range)[1];
+							for (const arg of expr.arguments) {
+								if (arg.type === "SpreadElement") return;
+								if (!parser.isPure(arg, pos)) return;
+								pos = /** @type {Range} */ (arg.range)[1];
+							}
+							const source = harmonySettings.source;
+							pureConditionByCallExpr.set(expr, (compilation, module) => {
+								const moduleGraph = compilation.moduleGraph;
+								for (const dep of module.dependencies) {
+									if (
+										dep instanceof HarmonyImportSideEffectDependency &&
+										dep.request === source
+									) {
+										const m = moduleGraph.getModule(dep);
+										if (!m) return false;
+										const exportInfo = moduleGraph
+											.getExportsInfo(m)
+											.getReadOnlyExportInfoRecursive(ids);
+										if (!exportInfo) return false;
+										const target = exportInfo.getTarget(moduleGraph);
+										const final =
+											target && target.export
+												? moduleGraph
+														.getExportsInfo(target.module)
+														.getReadOnlyExportInfoRecursive(target.export)
+												: exportInfo;
+										return final !== undefined && final.pureProvide === true;
+									}
+								}
+								return false;
+							});
+						}
+					);
+
 					// The following hooks are used during prewalking:
 
-					parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+					parser.hooks.preStatementByType
+						.for("FunctionDeclaration")
+						.tap(PLUGIN_NAME, (statement) => {
+							if (!innerGraph.isEnabled(parser.state)) return;
 
-						if (
-							parser.scope.topLevelScope === true &&
-							statement.type === "FunctionDeclaration"
-						) {
-							const name = statement.id ? statement.id.name : "*default*";
-							const symbol =
-								/** @type {TopLevelSymbol} */
-								(InnerGraph.tagTopLevelSymbol(parser, name));
-							statementWithTopLevelSymbol.set(statement, symbol);
-							return true;
-						}
-					});
+							if (
+								parser.scope.topLevelScope === true &&
+								statement.type === "FunctionDeclaration"
+							) {
+								const name = statement.id ? statement.id.name : "*default*";
+								const symbol = /** @type {TopLevelSymbol} */ (
+									innerGraph.tagTopLevelSymbol(
+										parser,
+										name,
+										parser.isPure(
+											statement,
+											/** @type {Range} */ (statement.range)[0]
+										)
+									)
+								);
+								statementWithTopLevelSymbol.set(statement, symbol);
+								return true;
+							}
+						});
 
-					parser.hooks.blockPreStatement.tap(PLUGIN_NAME, (statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+					/**
+					 * @param {import("estree").Statement | import("estree").ModuleDeclaration | import("estree").MaybeNamedFunctionDeclaration | import("estree").MaybeNamedClassDeclaration} statement statement
+					 * @returns {boolean | void} true when handled
+					 */
+					const blockPreStatementHandler = (statement) => {
+						if (!innerGraph.isEnabled(parser.state)) return;
 
 						if (parser.scope.topLevelScope === true) {
-							if (
-								statement.type === "ClassDeclaration" &&
-								parser.isPure(
+							if (statement.type === "ClassDeclaration") {
+								const name = statement.id ? statement.id.name : "*default*";
+								const pure = parser.isPure(
 									statement,
 									/** @type {Range} */ (statement.range)[0]
-								)
-							) {
-								const name = statement.id ? statement.id.name : "*default*";
+								);
 								const symbol = /** @type {TopLevelSymbol} */ (
-									InnerGraph.tagTopLevelSymbol(parser, name)
+									innerGraph.tagTopLevelSymbol(parser, name, pure)
 								);
 								classWithTopLevelSymbol.set(statement, symbol);
 								return true;
 							}
 							if (statement.type === "ExportDefaultDeclaration") {
 								const name = "*default*";
+								const decl = statement.declaration;
+								/** @type {boolean | ((compilation: Compilation, module: Module) => boolean)} */
+								let pure = parser.isPure(
+									decl,
+									/** @type {Range} */ (statement.range)[0]
+								);
+								if (!pure && decl.type === "CallExpression") {
+									const deferred = pureConditionByCallExpr.get(decl);
+									if (deferred) pure = deferred;
+								}
 								const symbol =
 									/** @type {TopLevelSymbol} */
-									(InnerGraph.tagTopLevelSymbol(parser, name));
-								const decl = statement.declaration;
+									(innerGraph.tagTopLevelSymbol(parser, name, pure));
 								if (
-									(decl.type === "ClassExpression" ||
-										decl.type === "ClassDeclaration") &&
-									parser.isPure(
-										/** @type {ClassExpression | ClassDeclaration} */
-										(decl),
-										/** @type {Range} */
-										(decl.range)[0]
-									)
+									decl.type === "ClassExpression" ||
+									decl.type === "ClassDeclaration"
 								) {
 									classWithTopLevelSymbol.set(
 										/** @type {ClassExpression | ClassDeclaration} */
 										(decl),
 										symbol
 									);
-								} else if (
-									parser.isPure(
-										/** @type {Expression} */
-										(decl),
-										/** @type {Range} */
-										(statement.range)[0]
-									)
-								) {
+								} else {
 									statementWithTopLevelSymbol.set(statement, symbol);
 									if (
+										pure &&
+										// body deferred to call-time, no eager read
 										!decl.type.endsWith("FunctionExpression") &&
+										// only FunctionDeclaration here (classes routed above), body deferred
 										!decl.type.endsWith("Declaration") &&
+										// literal references nothing
 										decl.type !== "Literal"
 									) {
 										statementPurePart.set(
@@ -196,38 +297,52 @@ class InnerGraphPlugin {
 								}
 							}
 						}
-					});
-
-					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, _statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+					};
+					parser.hooks.blockPreStatementByType
+						.for("ClassDeclaration")
+						.tap(PLUGIN_NAME, blockPreStatementHandler);
+					parser.hooks.blockPreStatementByType
+						.for("ExportDefaultDeclaration")
+						.tap(PLUGIN_NAME, blockPreStatementHandler);
+
+					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
+						if (!innerGraph.isEnabled(parser.state)) return;
+						if (impureVariableDeclarationKinds.has(statement.kind)) return;
 						if (
 							parser.scope.topLevelScope === true &&
 							decl.init &&
 							decl.id.type === "Identifier"
 						) {
 							const name = decl.id.name;
+							// Skip webpack runtime variables handled by CompatibilityPlugin
 							if (
-								decl.init.type === "ClassExpression" &&
-								parser.isPure(
-									decl.init,
-									/** @type {Range} */ (decl.id.range)[1]
-								)
+								name === RuntimeGlobals.require ||
+								name === RuntimeGlobals.exports
 							) {
+								return;
+							}
+							/** @type {boolean | ((compilation: Compilation, module: Module) => boolean)} */
+							let pure = parser.isPure(
+								decl.init,
+								/** @type {Range} */ (decl.id.range)[1]
+							);
+							if (!pure && decl.init.type === "CallExpression") {
+								const deferred = pureConditionByCallExpr.get(decl.init);
+								if (deferred) pure = deferred;
+							}
+
+							if (decl.init.type === "ClassExpression") {
 								const symbol =
 									/** @type {TopLevelSymbol} */
-									(InnerGraph.tagTopLevelSymbol(parser, name));
+									(innerGraph.tagTopLevelSymbol(parser, name, pure));
 								classWithTopLevelSymbol.set(decl.init, symbol);
-							} else if (
-								parser.isPure(
-									decl.init,
-									/** @type {Range} */ (decl.id.range)[1]
-								)
-							) {
+							} else {
 								const symbol =
 									/** @type {TopLevelSymbol} */
-									(InnerGraph.tagTopLevelSymbol(parser, name));
+									(innerGraph.tagTopLevelSymbol(parser, name, pure));
 								declWithTopLevelSymbol.set(decl, symbol);
 								if (
+									pure &&
 									!decl.init.type.endsWith("FunctionExpression") &&
 									decl.init.type !== "Literal"
 								) {
@@ -254,16 +369,19 @@ class InnerGraphPlugin {
 					// The following hooks are called during walking:
 
 					parser.hooks.statement.tap(PLUGIN_NAME, (statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (!innerGraph.isEnabled(parser.state)) return;
 						if (parser.scope.topLevelScope === true) {
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							innerGraph.setTopLevelSymbol(parser.state, undefined);
 
 							const symbol = statementWithTopLevelSymbol.get(statement);
 							if (symbol) {
-								InnerGraph.setTopLevelSymbol(parser.state, symbol);
+								innerGraph.setTopLevelSymbol(parser.state, symbol);
 								const purePart = statementPurePart.get(statement);
 								if (purePart) {
-									InnerGraph.onUsage(parser.state, (usedByExports) => {
+									// the callback fires after parsing, when the parser can no
+									// longer map offsets — take the location now
+									const loc = parser.getLocation(statement);
+									innerGraph.onUsage(parser.state, (usedByExports, module) => {
 										switch (usedByExports) {
 											case undefined:
 											case true:
@@ -272,11 +390,9 @@ class InnerGraphPlugin {
 												const dep = new PureExpressionDependency(
 													/** @type {Range} */ (purePart.range)
 												);
-												dep.loc =
-													/** @type {DependencyLocation} */
-													(statement.loc);
+												dep.loc = loc;
 												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
+												addPureDependency(module, dep);
 												break;
 											}
 										}
@@ -289,7 +405,7 @@ class InnerGraphPlugin {
 					parser.hooks.classExtendsExpression.tap(
 						PLUGIN_NAME,
 						(expr, statement) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (!innerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
 								const symbol = classWithTopLevelSymbol.get(statement);
 								if (
@@ -301,7 +417,7 @@ class InnerGraphPlugin {
 											: /** @type {Range} */ (statement.range)[0]
 									)
 								) {
-									InnerGraph.setTopLevelSymbol(parser.state, symbol);
+									innerGraph.setTopLevelSymbol(parser.state, symbol);
 									onUsageSuper(expr);
 								}
 							}
@@ -311,11 +427,11 @@ class InnerGraphPlugin {
 					parser.hooks.classBodyElement.tap(
 						PLUGIN_NAME,
 						(element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (!innerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
 								const symbol = classWithTopLevelSymbol.get(classDefinition);
 								if (symbol) {
-									InnerGraph.setTopLevelSymbol(parser.state, undefined);
+									innerGraph.setTopLevelSymbol(parser.state, undefined);
 								}
 							}
 						}
@@ -324,7 +440,7 @@ class InnerGraphPlugin {
 					parser.hooks.classBodyValue.tap(
 						PLUGIN_NAME,
 						(expression, element, classDefinition) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (!innerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
 								const symbol = classWithTopLevelSymbol.get(classDefinition);
 								if (symbol) {
@@ -337,29 +453,33 @@ class InnerGraphPlugin {
 												: /** @type {Range} */ (element.range)[0]
 										)
 									) {
-										InnerGraph.setTopLevelSymbol(parser.state, symbol);
+										innerGraph.setTopLevelSymbol(parser.state, symbol);
 										if (element.type !== "MethodDefinition" && element.static) {
-											InnerGraph.onUsage(parser.state, (usedByExports) => {
-												switch (usedByExports) {
-													case undefined:
-													case true:
-														return;
-													default: {
-														const dep = new PureExpressionDependency(
-															/** @type {Range} */ (expression.range)
-														);
-														dep.loc =
-															/** @type {DependencyLocation} */
-															(expression.loc);
-														dep.usedByExports = usedByExports;
-														parser.state.module.addDependency(dep);
-														break;
+											// the callback fires after parsing, when the parser can
+											// no longer map offsets — take the location now
+											const loc = parser.getLocation(expression);
+											innerGraph.onUsage(
+												parser.state,
+												(usedByExports, module) => {
+													switch (usedByExports) {
+														case undefined:
+														case true:
+															return;
+														default: {
+															const dep = new PureExpressionDependency(
+																/** @type {Range} */ (expression.range)
+															);
+															dep.loc = loc;
+															dep.usedByExports = usedByExports;
+															addPureDependency(module, dep);
+															break;
+														}
 													}
 												}
-											});
+											);
 										}
 									} else {
-										InnerGraph.setTopLevelSymbol(parser.state, undefined);
+										innerGraph.setTopLevelSymbol(parser.state, undefined);
 									}
 								}
 							}
@@ -367,11 +487,11 @@ class InnerGraphPlugin {
 					);
 
 					parser.hooks.declarator.tap(PLUGIN_NAME, (decl, _statement) => {
-						if (!InnerGraph.isEnabled(parser.state)) return;
+						if (!innerGraph.isEnabled(parser.state)) return;
 						const symbol = declWithTopLevelSymbol.get(decl);
 
 						if (symbol) {
-							InnerGraph.setTopLevelSymbol(parser.state, symbol);
+							innerGraph.setTopLevelSymbol(parser.state, symbol);
 							if (pureDeclarators.has(decl)) {
 								if (
 									/** @type {ClassExpression} */
@@ -381,7 +501,10 @@ class InnerGraphPlugin {
 										onUsageSuper(decl.init.superClass);
 									}
 								} else {
-									InnerGraph.onUsage(parser.state, (usedByExports) => {
+									// the callback fires after parsing, when the parser can no
+									// longer map offsets — take the location now
+									const loc = parser.getLocation(decl);
+									innerGraph.onUsage(parser.state, (usedByExports, module) => {
 										switch (usedByExports) {
 											case undefined:
 											case true:
@@ -393,9 +516,9 @@ class InnerGraphPlugin {
 														(decl.init).range
 													)
 												);
-												dep.loc = /** @type {DependencyLocation} */ (decl.loc);
+												dep.loc = loc;
 												dep.usedByExports = usedByExports;
-												parser.state.module.addDependency(dep);
+												addPureDependency(module, dep);
 												break;
 											}
 										}
@@ -407,7 +530,7 @@ class InnerGraphPlugin {
 									decl.init
 								)
 							);
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							innerGraph.setTopLevelSymbol(parser.state, undefined);
 							return true;
 						} else if (
 							decl.id.type === "Identifier" &&
@@ -416,7 +539,7 @@ class InnerGraphPlugin {
 							classWithTopLevelSymbol.has(decl.init)
 						) {
 							parser.walkExpression(decl.init);
-							InnerGraph.setTopLevelSymbol(parser.state, undefined);
+							innerGraph.setTopLevelSymbol(parser.state, undefined);
 							return true;
 						}
 					});
@@ -427,10 +550,10 @@ class InnerGraphPlugin {
 							const topLevelSymbol = /** @type {TopLevelSymbol} */ (
 								parser.currentTagData
 							);
-							const currentTopLevelSymbol = InnerGraph.getTopLevelSymbol(
+							const currentTopLevelSymbol = innerGraph.getTopLevelSymbol(
 								parser.state
 							);
-							InnerGraph.addUsage(
+							innerGraph.addUsage(
 								parser.state,
 								topLevelSymbol,
 								currentTopLevelSymbol || true
@@ -439,7 +562,7 @@ class InnerGraphPlugin {
 					parser.hooks.assign
 						.for(topLevelSymbolTag)
 						.tap(PLUGIN_NAME, (expr) => {
-							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (!innerGraph.isEnabled(parser.state)) return;
 							if (expr.operator === "=") return true;
 						});
 				};
@@ -450,8 +573,14 @@ class InnerGraphPlugin {
 					.for(JAVASCRIPT_MODULE_TYPE_ESM)
 					.tap(PLUGIN_NAME, handler);
 
-				compilation.hooks.finishModules.tap(PLUGIN_NAME, () => {
-					logger.timeAggregateEnd("infer dependency usage");
+				compilation.hooks.finishModules.tap(PLUGIN_NAME, (modules) => {
+					logger.time("infer dependency usage");
+					for (const module of modules) {
+						innerGraph.inferDependencyUsage(module);
+						// state is dead after inference; release it to not retain ASTs via callbacks
+						innerGraph.release(module);
+					}
+					logger.timeEnd("infer dependency usage");
 				});
 			}
 		);

package/lib/optimize/LimitChunkCountPlugin.js

@@ -14,6 +14,7 @@ const { compareChunks } = require("../util/comparators");
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * Defines the chunk combination type used by this module.
  * @typedef {object} ChunkCombination
  * @property {boolean} deleted this is set to true when combination was removed
  * @property {number} sizeDiff
@@ -27,6 +28,7 @@ const { compareChunks } = require("../util/comparators");
  */
 
 /**
+ * Adds the provided map to this object.
  * @template K, V
  * @param {Map<K, Set<V>>} map map
  * @param {K} key key
@@ -45,6 +47,7 @@ const PLUGIN_NAME = "LimitChunkCountPlugin";
 
 class LimitChunkCountPlugin {
 	/**
+	 * Creates an instance of LimitChunkCountPlugin.
 	 * @param {LimitChunkCountPluginOptions=} options options object
 	 */
 	constructor(options = { maxChunks: 1 }) {
@@ -53,6 +56,7 @@ class LimitChunkCountPlugin {
 	}
 
 	/**
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the webpack compiler
 	 * @returns {void}
 	 */
@@ -105,11 +109,13 @@ class LimitChunkCountPlugin {
 
 						// Layer 2: ordered by smallest combined size
 						/**
+						 * Handles the stage callback for this hook.
 						 * @param {ChunkCombination} c combination
 						 * @returns {number} integrated size
 						 */
 						(c) => c.integratedSize,
 						/**
+						 * Handles the callback logic for this hook.
 						 * @param {number} a a
 						 * @param {number} b b
 						 * @returns {number} result
@@ -118,11 +124,13 @@ class LimitChunkCountPlugin {
 
 						// Layer 3: ordered by position difference in orderedChunk (-> to be deterministic)
 						/**
+						 * Handles the callback logic for this hook.
 						 * @param {ChunkCombination} c combination
 						 * @returns {number} position difference
 						 */
 						(c) => c.bIdx - c.aIdx,
 						/**
+						 * Handles the callback logic for this hook.
 						 * @param {number} a a
 						 * @param {number} b b
 						 * @returns {number} result
@@ -131,6 +139,7 @@ class LimitChunkCountPlugin {
 
 						// Layer 4: ordered by position in orderedChunk (-> to be deterministic)
 						/**
+						 * Handles the callback logic for this hook.
 						 * @param {ChunkCombination} a a
 						 * @param {ChunkCombination} b b
 						 * @returns {number} result