@depup/webpack 5.106.0-depup.0 → 5.109.0-depup.0

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -8,6 +8,7 @@
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const AsyncWasmCompileRuntimeModule = require("../wasm-async/AsyncWasmCompileRuntimeModule");
 const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRuntimeModule");
 
@@ -15,6 +16,15 @@ const AsyncWasmLoadingRuntimeModule = require("../wasm-async/AsyncWasmLoadingRun
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
+/**
+ * Defines the read file compile async wasm plugin options type used by this module.
  * @typedef {object} ReadFileCompileAsyncWasmPluginOptions
  * @property {boolean=} import use import?
  */
@@ -23,6 +33,7 @@ const PLUGIN_NAME = "ReadFileCompileAsyncWasmPlugin";
 
 class ReadFileCompileAsyncWasmPlugin {
 	/**
+	 * Creates an instance of ReadFileCompileAsyncWasmPlugin.
 	 * @param {ReadFileCompileAsyncWasmPluginOptions=} options options object
 	 */
 	constructor({ import: useImport = false } = {}) {
@@ -31,7 +42,7 @@ class ReadFileCompileAsyncWasmPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -39,6 +50,7 @@ class ReadFileCompileAsyncWasmPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalWasmLoading = compilation.outputOptions.wasmLoading;
 			/**
+			 * Checks whether this read file compile async wasm plugin is enabled for chunk.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, if wasm loading is enabled for the chunk
 			 */
@@ -109,6 +121,11 @@ class ReadFileCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmLoadingRuntimeModule({
@@ -130,6 +147,11 @@ class ReadFileCompileAsyncWasmPlugin {
 					) {
 						return;
 					}
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new AsyncWasmCompileRuntimeModule({

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -8,12 +8,22 @@
 const { WEBASSEMBLY_MODULE_TYPE_SYNC } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { getPresentKinds } = require("../TemplatedPathPlugin");
 const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRuntimeModule");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * The wasm runtime inlines `[fullhash]` as a runtime `getFullHash()` call, so
+ * that runtime module must be requested (`[hash]` is the per-module hash here).
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} whether it references the compilation `[fullhash]`
+ */
+const usesFullHash = (filename) => getPresentKinds(filename).has("fullhash");
+
+/**
+ * Defines the read file compile wasm plugin options type used by this module.
  * @typedef {object} ReadFileCompileWasmPluginOptions
  * @property {boolean=} mangleImports mangle imports
  * @property {boolean=} import use import?
@@ -23,6 +33,7 @@ const PLUGIN_NAME = "ReadFileCompileWasmPlugin";
 
 class ReadFileCompileWasmPlugin {
 	/**
+	 * Creates an instance of ReadFileCompileWasmPlugin.
 	 * @param {ReadFileCompileWasmPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
@@ -31,7 +42,7 @@ class ReadFileCompileWasmPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -39,6 +50,7 @@ class ReadFileCompileWasmPlugin {
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const globalWasmLoading = compilation.outputOptions.wasmLoading;
 			/**
+			 * Checks whether this read file compile wasm plugin is enabled for chunk.
 			 * @param {Chunk} chunk chunk
 			 * @returns {boolean} true, when wasm loading is enabled for the chunk
 			 */
@@ -110,6 +122,11 @@ class ReadFileCompileWasmPlugin {
 						return;
 					}
 					set.add(RuntimeGlobals.moduleCache);
+					if (
+						usesFullHash(compilation.outputOptions.webassemblyModuleFilename)
+					) {
+						set.add(RuntimeGlobals.getFullHash);
+					}
 					compilation.addRuntimeModule(
 						chunk,
 						new WasmChunkLoadingRuntimeModule({

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -26,6 +26,7 @@ const { getUndoPath } = require("../util/identifier");
 
 class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	/**
+	 * Creates an instance of RequireChunkLoadingRuntimeModule.
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
 	 */
 	constructor(runtimeRequirements) {
@@ -35,6 +36,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Returns generated code.
 	 * @private
 	 * @param {Chunk} chunk chunk
 	 * @param {string} rootOutputDir root output directory
@@ -55,6 +57,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	}
 
 	/**
+	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
 	 */
 	generate() {
@@ -100,6 +103,12 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_require`
 			: undefined;
 
+		const cst = runtimeTemplate.renderConst();
+		const installedChunksObject = `{\n${Template.indent(
+			Array.from(initialChunkIds, (id) => `${JSON.stringify(id)}: 1`).join(
+				",\n"
+			)
+		)}\n}`;
 		return Template.asString([
 			withBaseURI
 				? this._generateBaseUri(chunk, rootOutputDir, runtimeTemplate)
@@ -107,15 +116,11 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 			"",
 			"// object to store loaded chunks",
 			'// "1" means "loaded", otherwise not loaded yet',
-			`var installedChunks = ${
-				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
-			}{`,
-			Template.indent(
-				Array.from(initialChunkIds, (id) => `${JSON.stringify(id)}: 1`).join(
-					",\n"
-				)
-			),
-			"};",
+			`${cst} installedChunks = ${
+				stateExpression
+					? runtimeTemplate.assignOr(stateExpression, installedChunksObject)
+					: installedChunksObject
+			};`,
 			"",
 			withOnChunkLoad
 				? `${
@@ -127,8 +132,8 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 				: "// no on chunks loaded",
 			"",
 			withLoading || withExternalInstallChunk
-				? `var installChunk = ${runtimeTemplate.basicFunction("chunk", [
-						"var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;",
+				? `${cst} installChunk = ${runtimeTemplate.basicFunction("chunk", [
+						`${cst} moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;`,
 						"for(var moduleId in moreModules) {",
 						Template.indent([
 							`if(${RuntimeGlobals.hasOwnProperty}(moreModules, moduleId)) {`,
@@ -161,7 +166,7 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 											Template.indent([
 												// The require function loads and runs a chunk. When the chunk is being run,
 												// it can call __webpack_require__.C to directly complete installed.
-												`var installedChunk = require(${JSON.stringify(
+												`${cst} installedChunk = require(${JSON.stringify(
 													rootOutputDir
 												)} + ${
 													RuntimeGlobals.getChunkScriptFilename
@@ -191,17 +196,17 @@ class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 				? Template.asString([
 						"function loadUpdateChunk(chunkId, updatedModulesList) {",
 						Template.indent([
-							`var update = require(${JSON.stringify(rootOutputDir)} + ${
+							`${cst} update = require(${JSON.stringify(rootOutputDir)} + ${
 								RuntimeGlobals.getChunkUpdateScriptFilename
 							}(chunkId));`,
-							"var updatedModules = update.modules;",
-							"var runtime = update.runtime;",
+							`${cst} updatedModules = update.modules;`,
+							`${cst} runtime = update.runtime;`,
 							"for(var moduleId in updatedModules) {",
 							Template.indent([
 								`if(${RuntimeGlobals.hasOwnProperty}(updatedModules, moduleId)) {`,
 								Template.indent([
 									"currentUpdate[moduleId] = updatedModules[moduleId];",
-									"if(updatedModulesList) updatedModulesList.push(moduleId);"
+									`${runtimeTemplate.optionalChaining("updatedModulesList", "push(moduleId)")};`
 								]),
 								"}"
 							]),

package/lib/node/nodeBuiltins.js

@@ -0,0 +1,80 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q @sheo13666q
+*/
+
+"use strict";
+
+// node.js built-in modules externalized by the node/deno/bun target presets.
+const builtins = [
+	"assert",
+	"assert/strict",
+	"async_hooks",
+	"buffer",
+	"child_process",
+	"cluster",
+	"console",
+	"constants",
+	"crypto",
+	"dgram",
+	"diagnostics_channel",
+	"dns",
+	"dns/promises",
+	"domain",
+	"events",
+	"fs",
+	"fs/promises",
+	"http",
+	"http2",
+	"https",
+	"inspector",
+	"inspector/promises",
+	"module",
+	"net",
+	"os",
+	"path",
+	"path/posix",
+	"path/win32",
+	"perf_hooks",
+	"process",
+	"punycode",
+	"querystring",
+	"readline",
+	"readline/promises",
+	"repl",
+	"stream",
+	"stream/consumers",
+	"stream/promises",
+	"stream/web",
+	"string_decoder",
+	"sys",
+	"timers",
+	"timers/promises",
+	"tls",
+	"trace_events",
+	"tty",
+	"url",
+	"util",
+	"util/types",
+	"v8",
+	"vm",
+	"wasi",
+	"worker_threads",
+	"zlib",
+	/^node:/,
+
+	// cspell:word pnpapi
+	// Yarn PnP adds pnpapi as "builtin"
+	"pnpapi"
+];
+
+// Bare core module names (no `node:` prefix, no regex, no pnpapi), used to
+// recognize a request that has a `node:`-prefixed equivalent.
+const coreModules = new Set(
+	builtins.filter(
+		(builtin) => typeof builtin === "string" && builtin !== "pnpapi"
+	)
+);
+
+module.exports.builtins = builtins;
+module.exports.coreModules = coreModules;

package/lib/node/nodeConsole.js

@@ -7,120 +7,175 @@
 
 const util = require("util");
 const truncateArgs = require("../logging/truncateArgs");
+const memoize = require("../util/memoize");
 
+const getCli = memoize(() => require("../cli"));
+
+const ESC = "\u001B[";
+const CURSOR_UP = `${ESC}1A`;
+const CLEAR_LINE = `${ESC}2K\r`;
+
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../config/defaults").InfrastructureLoggingNormalizedWithDefaults} InfrastructureLoggingNormalizedWithDefaults */
 /** @typedef {import("../logging/createConsoleLogger").LoggerConsole} LoggerConsole */
+/**
+ * @typedef {object} StatusMessageState
+ * @property {string[] | undefined} currentMessage current status message
+ * @property {number} currentLines current status message rows
+ */
+
+/** @type {WeakMap<Compiler, StatusMessageState>} */
+const logStatusStateByCompiler = new WeakMap();
+/** @type {Set<StatusMessageState>} */
+const logStatusStates = new Set();
+
+/**
+ * Returns status state
+ * @param {Compiler} compiler compiler
+ * @returns {StatusMessageState} status state
+ */
+const getLogStatusState = (compiler) => {
+	let state = logStatusStateByCompiler.get(compiler);
+	if (state === undefined) {
+		state = {
+			currentMessage: undefined,
+			currentLines: 0
+		};
+		logStatusStateByCompiler.set(compiler, state);
+		logStatusStates.add(state);
+	}
+	return state;
+};
 
 /* eslint-disable no-console */
 
 /**
+ * Returns logger function.
  * @param {object} options options
  * @param {boolean=} options.colors colors
  * @param {boolean=} options.appendOnly append only
  * @param {InfrastructureLoggingNormalizedWithDefaults["stream"]} options.stream stream
+ * @param {Compiler} options.compiler compiler
  * @returns {LoggerConsole} logger function
  */
-module.exports = ({ colors, appendOnly, stream }) => {
-	/** @type {string[] | undefined} */
-	let currentStatusMessage;
-	let hasStatusMessage = false;
+module.exports = ({ colors, appendOnly, stream, compiler }) => {
+	const c = getCli().createColors({ useColor: Boolean(colors) });
+	const logStatusState = getLogStatusState(compiler);
+
 	let currentIndent = "";
 	let currentCollapsed = 0;
 
 	/**
+	 * Returns indented string.
 	 * @param {string} str string
 	 * @param {string} prefix prefix
-	 * @param {string} colorPrefix color prefix
-	 * @param {string} colorSuffix color suffix
+	 * @param {(line: string) => string} colorFn color function
 	 * @returns {string} indented string
 	 */
-	const indent = (str, prefix, colorPrefix, colorSuffix) => {
+	const indent = (str, prefix, colorFn) => {
 		if (str === "") return str;
 		prefix = currentIndent + prefix;
-		if (colors) {
-			return (
-				prefix +
-				colorPrefix +
-				str.replace(/\n/g, `${colorSuffix}\n${prefix}${colorPrefix}`) +
-				colorSuffix
-			);
-		}
-
-		return prefix + str.replace(/\n/g, `\n${prefix}`);
+		return (
+			prefix +
+			str
+				.split("\n")
+				.map((line) => colorFn(line))
+				.join(`\n${prefix}`)
+		);
 	};
 
 	const clearStatusMessage = () => {
-		if (hasStatusMessage) {
-			stream.write("\u001B[2K\r");
-			hasStatusMessage = false;
+		let lines = 0;
+		for (const state of logStatusStates) {
+			if (state.currentLines) {
+				lines += state.currentLines;
+				state.currentLines = 0;
+			}
+		}
+		for (let i = 0; i < lines; i++) {
+			if (i > 0) stream.write(CURSOR_UP);
+			stream.write(CLEAR_LINE);
 		}
 	};
 
 	const writeStatusMessage = () => {
-		if (!currentStatusMessage) return;
-		const l = stream.columns || 40;
-		const args = truncateArgs(currentStatusMessage, l - 1);
-		const str = args.join(" ");
-		const coloredStr = `\u001B[1m${str}\u001B[39m\u001B[22m`;
-		stream.write(`\u001B[2K\r${coloredStr}`);
-		hasStatusMessage = true;
+		const column = stream.columns || 40;
+		/** @type {string[]} */
+		const all = [];
+
+		for (const state of logStatusStates) {
+			if (!state.currentMessage) continue;
+			/** @type {string[][]} */
+			const lines = [[]];
+			for (const item of state.currentMessage) {
+				const parts = item.split("\n");
+				lines[lines.length - 1].push(parts[0]);
+				for (let i = 1; i < parts.length; i++) {
+					lines.push([parts[i]]);
+				}
+			}
+			const truncateLines = lines.map((args) =>
+				truncateArgs(args, column - 1).join(" ")
+			);
+			state.currentLines = truncateLines.length;
+			for (const line of truncateLines) all.push(line);
+		}
+		if (all.length === 0) return;
+
+		const coloredLines = all.map((str) => c.bold(str));
+		stream.write(`${CLEAR_LINE}${coloredLines.join(`\n${CLEAR_LINE}`)}`);
 	};
 
 	/**
+	 * @param {EXPECTED_ANY[]} statusMessage status message
+	 * @returns {void}
+	 */
+	const setStatusMessage = (statusMessage) => {
+		clearStatusMessage();
+		logStatusState.currentMessage = statusMessage.map((item) => `${item}`);
+		writeStatusMessage();
+	};
+
+	/**
+	 * Returns function to write with colors.
 	 * @template T
 	 * @param {string} prefix prefix
-	 * @param {string} colorPrefix color prefix
-	 * @param {string} colorSuffix color suffix
+	 * @param {(line: string) => string} colorFn color function
 	 * @returns {(...args: T[]) => void} function to write with colors
 	 */
 	const writeColored =
-		(prefix, colorPrefix, colorSuffix) =>
+		(prefix, colorFn) =>
 		(...args) => {
 			if (currentCollapsed > 0) return;
 			clearStatusMessage();
-			const str = indent(
-				util.format(...args),
-				prefix,
-				colorPrefix,
-				colorSuffix
-			);
+			const str = indent(util.format(...args), prefix, colorFn);
 			stream.write(`${str}\n`);
 			writeStatusMessage();
 		};
 
 	/** @type {<T extends unknown[]>(...args: T) => void} */
-	const writeGroupMessage = writeColored(
-		"<-> ",
-		"\u001B[1m\u001B[36m",
-		"\u001B[39m\u001B[22m"
-	);
+	const writeGroupMessage = writeColored("<-> ", (str) => c.bold(c.cyan(str)));
 
 	/** @type {<T extends unknown[]>(...args: T) => void} */
-	const writeGroupCollapsedMessage = writeColored(
-		"<+> ",
-		"\u001B[1m\u001B[36m",
-		"\u001B[39m\u001B[22m"
+	const writeGroupCollapsedMessage = writeColored("<+> ", (str) =>
+		c.bold(c.cyan(str))
 	);
 
 	return {
 		/** @type {LoggerConsole["log"]} */
-		log: writeColored("    ", "\u001B[1m", "\u001B[22m"),
+		log: writeColored("    ", c.bold),
 		/** @type {LoggerConsole["debug"]} */
-		debug: writeColored("    ", "", ""),
+		debug: writeColored("    ", String),
 		/** @type {LoggerConsole["trace"]} */
-		trace: writeColored("    ", "", ""),
+		trace: writeColored("    ", String),
 		/** @type {LoggerConsole["info"]} */
-		info: writeColored("<i> ", "\u001B[1m\u001B[32m", "\u001B[39m\u001B[22m"),
+		info: writeColored("<i> ", (str) => c.bold(c.green(str))),
 		/** @type {LoggerConsole["warn"]} */
-		warn: writeColored("<w> ", "\u001B[1m\u001B[33m", "\u001B[39m\u001B[22m"),
+		warn: writeColored("<w> ", (str) => c.bold(c.yellow(str))),
 		/** @type {LoggerConsole["error"]} */
-		error: writeColored("<e> ", "\u001B[1m\u001B[31m", "\u001B[39m\u001B[22m"),
+		error: writeColored("<e> ", (str) => c.bold(c.red(str))),
 		/** @type {LoggerConsole["logTime"]} */
-		logTime: writeColored(
-			"<t> ",
-			"\u001B[1m\u001B[35m",
-			"\u001B[39m\u001B[22m"
-		),
+		logTime: writeColored("<t> ", (str) => c.bold(c.magenta(str))),
 		/** @type {LoggerConsole["group"]} */
 		group: (...args) => {
 			writeGroupMessage(...args);
@@ -161,24 +216,21 @@ module.exports = ({ colors, appendOnly, stream }) => {
 			),
 		/** @type {LoggerConsole["status"]} */
 		status: appendOnly
-			? writeColored("<s> ", "", "")
+			? writeColored("<s> ", String)
 			: (name, ...args) => {
 					args = args.filter(Boolean);
 					if (name === undefined && args.length === 0) {
 						clearStatusMessage();
-						currentStatusMessage = undefined;
+						logStatusState.currentMessage = undefined;
 					} else if (
 						typeof name === "string" &&
 						name.startsWith("[webpack.Progress] ")
 					) {
-						currentStatusMessage = [name.slice(19), ...args];
-						writeStatusMessage();
+						setStatusMessage([name.slice(19), ...args]);
 					} else if (name === "[webpack.Progress]") {
-						currentStatusMessage = [...args];
-						writeStatusMessage();
+						setStatusMessage([...args]);
 					} else {
-						currentStatusMessage = [name, ...args];
-						writeStatusMessage();
+						setStatusMessage([name, ...args]);
 					}
 				}
 	};

package/lib/optimize/AggressiveMergingPlugin.js

@@ -11,6 +11,7 @@ const { STAGE_ADVANCED } = require("../OptimizationStages");
 /** @typedef {import("../Compiler")} Compiler */
 
 /**
+ * Defines the aggressive merging plugin options type used by this module.
  * @typedef {object} AggressiveMergingPluginOptions
  * @property {number=} minSizeReduce minimal size reduction to trigger merging
  */
@@ -19,6 +20,7 @@ const PLUGIN_NAME = "AggressiveMergingPlugin";
 
 class AggressiveMergingPlugin {
 	/**
+	 * Creates an instance of AggressiveMergingPlugin.
 	 * @param {AggressiveMergingPluginOptions=} options options object
 	 */
 	constructor(options) {
@@ -35,7 +37,7 @@ class AggressiveMergingPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */

package/lib/optimize/AggressiveSplittingPlugin.js

@@ -21,6 +21,7 @@ const identifierUtils = require("../util/identifier");
 /** @typedef {import("../Module")} Module */
 
 /**
+ * Move module between.
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Chunk} oldChunk the old chunk
  * @param {Chunk} newChunk the new chunk
@@ -32,6 +33,7 @@ const moveModuleBetween = (chunkGraph, oldChunk, newChunk) => (module) => {
 };
 
 /**
+ * Checks whether this object is not a entry module.
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Chunk} chunk the chunk
  * @returns {(module: Module) => boolean} filter for entry module
@@ -48,6 +50,7 @@ const PLUGIN_NAME = "AggressiveSplittingPlugin";
 
 class AggressiveSplittingPlugin {
 	/**
+	 * Creates an instance of AggressiveSplittingPlugin.
 	 * @param {AggressiveSplittingPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
@@ -56,6 +59,7 @@ class AggressiveSplittingPlugin {
 	}
 
 	/**
+	 * Was chunk recorded.
 	 * @param {Chunk} chunk the chunk to test
 	 * @returns {boolean} true if the chunk was recorded
 	 */
@@ -64,7 +68,7 @@ class AggressiveSplittingPlugin {
 	}
 
 	/**
-	 * Apply the plugin
+	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
@@ -138,6 +142,7 @@ class AggressiveSplittingPlugin {
 					const maxSize = this.options.maxSize || 50 * 1024;
 
 					/**
+					 * Returns true when applied, otherwise false.
 					 * @param {SplitData} splitData split data
 					 * @returns {boolean} true when applied, otherwise false
 					 */