webpack 5.59.0 → 5.94.0

package/lib/NormalModuleReplacementPlugin.js

@@ -8,7 +8,9 @@
 const { join, dirname } = require("./util/fs");
 
 /** @typedef {import("./Compiler")} Compiler */
-/** @typedef {function(TODO): void} ModuleReplacer */
+/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+
+/** @typedef {function(import("./NormalModuleFactory").ResolveData): void} ModuleReplacer */
 
 class NormalModuleReplacementPlugin {
 	/**
@@ -43,11 +45,15 @@ class NormalModuleReplacementPlugin {
 				});
 				nmf.hooks.afterResolve.tap("NormalModuleReplacementPlugin", result => {
 					const createData = result.createData;
-					if (resourceRegExp.test(createData.resource)) {
+					if (
+						resourceRegExp.test(/** @type {string} */ (createData.resource))
+					) {
 						if (typeof newResource === "function") {
 							newResource(result);
 						} else {
-							const fs = compiler.inputFileSystem;
+							const fs =
+								/** @type {InputFileSystem} */
+								(compiler.inputFileSystem);
 							if (
 								newResource.startsWith("/") ||
 								(newResource.length > 1 && newResource[1] === ":")
@@ -56,7 +62,7 @@ class NormalModuleReplacementPlugin {
 							} else {
 								createData.resource = join(
 									fs,
-									dirname(fs, createData.resource),
+									dirname(fs, /** @type {string} */ (createData.resource)),
 									newResource
 								);
 							}

package/lib/NullFactory.js

@@ -13,7 +13,7 @@ const ModuleFactory = require("./ModuleFactory");
 class NullFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {

package/lib/OptimizationStages.js

@@ -5,6 +5,6 @@
 
 "use strict";
 
-exports.STAGE_BASIC = -10;
-exports.STAGE_DEFAULT = 0;
-exports.STAGE_ADVANCED = 10;
+module.exports.STAGE_BASIC = -10;
+module.exports.STAGE_DEFAULT = 0;
+module.exports.STAGE_ADVANCED = 10;

package/lib/Parser.js

@@ -11,7 +11,7 @@
 /** @typedef {Record<string, any>} PreparsedAst */
 
 /**
- * @typedef {Object} ParserStateBase
+ * @typedef {object} ParserStateBase
  * @property {string | Buffer} source
  * @property {NormalModule} current
  * @property {NormalModule} module

package/lib/PlatformPlugin.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Authors Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./config/target").PlatformTargetProperties} PlatformTargetProperties */
+
+/**
+ * Should be used only for "target === false" or
+ * when you want to overwrite platform target properties
+ */
+class PlatformPlugin {
+	/**
+	 * @param {Partial<PlatformTargetProperties>} platform target properties
+	 */
+	constructor(platform) {
+		/** @type {Partial<PlatformTargetProperties>} */
+		this.platform = platform;
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.environment.tap("PlatformPlugin", () => {
+			compiler.platform = {
+				...compiler.platform,
+				...this.platform
+			};
+		});
+	}
+}
+
+module.exports = PlatformPlugin;

package/lib/PrefetchPlugin.js

@@ -10,6 +10,10 @@ const PrefetchDependency = require("./dependencies/PrefetchDependency");
 /** @typedef {import("./Compiler")} Compiler */
 
 class PrefetchPlugin {
+	/**
+	 * @param {string} context context or request if context is not set
+	 * @param {string} [request] request
+	 */
 	constructor(context, request) {
 		if (request) {
 			this.context = context;

package/lib/ProgressPlugin.js

@@ -11,9 +11,20 @@ const NormalModule = require("./NormalModule");
 const createSchemaValidation = require("./util/create-schema-validation");
 const { contextify } = require("./util/identifier");
 
+/** @typedef {import("tapable").Tap} Tap */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").HandlerFunction} HandlerFunction */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginArgument} ProgressPluginArgument */
 /** @typedef {import("../declarations/plugins/ProgressPlugin").ProgressPluginOptions} ProgressPluginOptions */
+/** @typedef {import("./Dependency")} Dependency */
+/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./logging/Logger").Logger} Logger */
+
+/**
+ * @typedef {object} CountsData
+ * @property {number} modulesCount modules count
+ * @property {number} dependenciesCount dependencies count
+ */
 
 const validate = createSchemaValidation(
 	require("../schemas/plugins/ProgressPlugin.check.js"),
@@ -23,14 +34,29 @@ const validate = createSchemaValidation(
 		baseDataPath: "options"
 	}
 );
-const median3 = (a, b, c) => {
-	return a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
-};
 
+/**
+ * @param {number} a a
+ * @param {number} b b
+ * @param {number} c c
+ * @returns {number} median
+ */
+const median3 = (a, b, c) => a + b + c - Math.max(a, b, c) - Math.min(a, b, c);
+
+/**
+ * @param {boolean | null | undefined} profile need profile
+ * @param {Logger} logger logger
+ * @returns {defaultHandler} default handler
+ */
 const createDefaultHandler = (profile, logger) => {
-	/** @type {{ value: string, time: number }[]} */
+	/** @type {{ value: string | undefined, time: number }[]} */
 	const lastStateInfo = [];
 
+	/**
+	 * @param {number} percentage percentage
+	 * @param {string} msg message
+	 * @param {...string} args additional arguments
+	 */
 	const defaultHandler = (percentage, msg, ...args) => {
 		if (profile) {
 			if (percentage === 0) {
@@ -50,11 +76,12 @@ const createDefaultHandler = (profile, logger) => {
 						if (lastStateItem.value) {
 							let reportState = lastStateItem.value;
 							if (i > 0) {
-								reportState = lastStateInfo[i - 1].value + " > " + reportState;
+								reportState = `${lastStateInfo[i - 1].value} > ${reportState}`;
 							}
 							const stateMsg = `${" | ".repeat(i)}${diff} ms ${reportState}`;
 							const d = diff;
 							// This depends on timing so we ignore it for coverage
+							/* eslint-disable no-lone-blocks */
 							/* istanbul ignore next */
 							{
 								if (d > 10000) {
@@ -69,6 +96,7 @@ const createDefaultHandler = (profile, logger) => {
 									logger.debug(stateMsg);
 								}
 							}
+							/* eslint-enable no-lone-blocks */
 						}
 						if (stateItem === undefined) {
 							lastStateInfo.length = i;
@@ -95,18 +123,18 @@ const createDefaultHandler = (profile, logger) => {
 
 /**
  * @callback ReportProgress
- * @param {number} p
- * @param {...string[]} [args]
+ * @param {number} p percentage
+ * @param {...string} args additional arguments
  * @returns {void}
  */
 
-/** @type {WeakMap<Compiler,ReportProgress>} */
+/** @type {WeakMap<Compiler, ReportProgress | undefined>} */
 const progressReporters = new WeakMap();
 
 class ProgressPlugin {
 	/**
 	 * @param {Compiler} compiler the current compiler
-	 * @returns {ReportProgress} a progress reporter, if any
+	 * @returns {ReportProgress | undefined} a progress reporter, if any
 	 */
 	static getReporter(compiler) {
 		return progressReporters.get(compiler);
@@ -163,14 +191,14 @@ class ProgressPlugin {
 		const states = compiler.compilers.map(
 			() => /** @type {[number, ...string[]]} */ ([0])
 		);
-		compiler.compilers.forEach((compiler, idx) => {
+		for (const [idx, item] of compiler.compilers.entries()) {
 			new ProgressPlugin((p, msg, ...args) => {
 				states[idx] = [p, msg, ...args];
 				let sum = 0;
 				for (const [p] of states) sum += p;
 				handler(sum / states.length, `[${idx}] ${msg}`, ...args);
-			}).apply(compiler);
-		});
+			}).apply(item);
+		}
 	}
 
 	/**
@@ -288,6 +316,9 @@ class ProgressPlugin {
 		};
 
 		// only used when showActiveModules is set
+		/**
+		 * @param {Module} module the module
+		 */
 		const moduleBuild = module => {
 			const ident = module.identifier();
 			if (ident) {
@@ -297,11 +328,18 @@ class ProgressPlugin {
 			}
 		};
 
+		/**
+		 * @param {Dependency} entry entry dependency
+		 * @param {EntryOptions} options options object
+		 */
 		const entryAdd = (entry, options) => {
 			entriesCount++;
 			if (entriesCount < 5 || entriesCount % 10 === 0) updateThrottled();
 		};
 
+		/**
+		 * @param {Module} module the module
+		 */
 		const moduleDone = module => {
 			doneModules++;
 			if (showActiveModules) {
@@ -321,6 +359,10 @@ class ProgressPlugin {
 			if (doneModules < 50 || doneModules % 100 === 0) updateThrottled();
 		};
 
+		/**
+		 * @param {Dependency} entry entry dependency
+		 * @param {EntryOptions} options options object
+		 */
 		const entryDone = (entry, options) => {
 			doneEntries++;
 			update();
@@ -330,6 +372,7 @@ class ProgressPlugin {
 			.getCache("ProgressPlugin")
 			.getItemCache("counts", null);
 
+		/** @type {Promise<CountsData> | undefined} */
 		let cacheGetPromise;
 
 		compiler.hooks.beforeCompile.tap("ProgressPlugin", () => {
@@ -352,15 +395,17 @@ class ProgressPlugin {
 
 		compiler.hooks.afterCompile.tapPromise("ProgressPlugin", compilation => {
 			if (compilation.compiler.isChild()) return Promise.resolve();
-			return cacheGetPromise.then(async oldData => {
-				if (
-					!oldData ||
-					oldData.modulesCount !== modulesCount ||
-					oldData.dependenciesCount !== dependenciesCount
-				) {
-					await cache.storePromise({ modulesCount, dependenciesCount });
+			return /** @type {Promise<CountsData>} */ (cacheGetPromise).then(
+				async oldData => {
+					if (
+						!oldData ||
+						oldData.modulesCount !== modulesCount ||
+						oldData.dependenciesCount !== dependenciesCount
+					) {
+						await cache.storePromise({ modulesCount, dependenciesCount });
+					}
 				}
-			});
+			);
 		});
 
 		compiler.hooks.compilation.tap("ProgressPlugin", compilation => {
@@ -462,10 +507,10 @@ class ProgressPlugin {
 				afterSeal: "after seal"
 			};
 			const numberOfHooks = Object.keys(hooks).length;
-			Object.keys(hooks).forEach((name, idx) => {
-				const title = hooks[name];
+			for (const [idx, name] of Object.keys(hooks).entries()) {
+				const title = hooks[/** @type {keyof typeof hooks} */ (name)];
 				const percentage = (idx / numberOfHooks) * 0.25 + 0.7;
-				compilation.hooks[name].intercept({
+				compilation.hooks[/** @type {keyof typeof hooks} */ (name)].intercept({
 					name: "ProgressPlugin",
 					call() {
 						handler(percentage, "sealing", title);
@@ -489,7 +534,7 @@ class ProgressPlugin {
 						handler(percentage, "sealing", title, tap.name);
 					}
 				});
-			});
+			}
 		});
 		compiler.hooks.make.intercept({
 			name: "ProgressPlugin",
@@ -500,6 +545,12 @@ class ProgressPlugin {
 				handler(0.65, "building");
 			}
 		});
+		/**
+		 * @param {TODO} hook hook
+		 * @param {number} progress progress from 0 to 1
+		 * @param {string} category category
+		 * @param {string} name name
+		 */
 		const interceptHook = (hook, progress, category, name) => {
 			hook.intercept({
 				name: "ProgressPlugin",
@@ -516,6 +567,9 @@ class ProgressPlugin {
 				error() {
 					handler(progress, category, name);
 				},
+				/**
+				 * @param {Tap} tap tap
+				 */
 				tap(tap) {
 					progressReporters.set(compiler, (p, ...args) => {
 						handler(progress, category, name, tap.name, ...args);
@@ -531,15 +585,14 @@ class ProgressPlugin {
 			}
 		});
 		interceptHook(compiler.cache.hooks.endIdle, 0.01, "cache", "end idle");
-		compiler.hooks.initialize.intercept({
+		compiler.hooks.beforeRun.intercept({
 			name: "ProgressPlugin",
 			call() {
 				handler(0, "");
 			}
 		});
-		interceptHook(compiler.hooks.initialize, 0.01, "setup", "initialize");
-		interceptHook(compiler.hooks.beforeRun, 0.02, "setup", "before run");
-		interceptHook(compiler.hooks.run, 0.03, "setup", "run");
+		interceptHook(compiler.hooks.beforeRun, 0.01, "setup", "before run");
+		interceptHook(compiler.hooks.run, 0.02, "setup", "run");
 		interceptHook(compiler.hooks.watchRun, 0.03, "setup", "watch run");
 		interceptHook(
 			compiler.hooks.normalModuleFactory,
@@ -611,4 +664,6 @@ ProgressPlugin.defaultOptions = {
 	entries: true
 };
 
+ProgressPlugin.createDefaultHandler = createDefaultHandler;
+
 module.exports = ProgressPlugin;

package/lib/ProvidePlugin.js

@@ -5,11 +5,22 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("./ModuleTypeConstants");
 const ConstDependency = require("./dependencies/ConstDependency");
 const ProvidedDependency = require("./dependencies/ProvidedDependency");
 const { approve } = require("./javascript/JavascriptParserHelpers");
 
+/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
+
+const PLUGIN_NAME = "ProvidePlugin";
 
 class ProvidePlugin {
 	/**
@@ -27,7 +38,7 @@ class ProvidePlugin {
 	apply(compiler) {
 		const definitions = this.definitions;
 		compiler.hooks.compilation.tap(
-			"ProvidePlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyTemplates.set(
 					ConstDependency,
@@ -41,18 +52,25 @@ class ProvidePlugin {
 					ProvidedDependency,
 					new ProvidedDependency.Template()
 				);
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {JavascriptParserOptions} parserOptions options
+				 * @returns {void}
+				 */
 				const handler = (parser, parserOptions) => {
-					Object.keys(definitions).forEach(name => {
-						const request = [].concat(definitions[name]);
+					for (const name of Object.keys(definitions)) {
+						const request =
+							/** @type {string[]} */
+							([]).concat(definitions[name]);
 						const splittedName = name.split(".");
 						if (splittedName.length > 0) {
-							splittedName.slice(1).forEach((_, i) => {
+							for (const [i, _] of splittedName.slice(1).entries()) {
 								const name = splittedName.slice(0, i + 1).join(".");
-								parser.hooks.canRename.for(name).tap("ProvidePlugin", approve);
-							});
+								parser.hooks.canRename.for(name).tap(PLUGIN_NAME, approve);
+							}
 						}
 
-						parser.hooks.expression.for(name).tap("ProvidePlugin", expr => {
+						parser.hooks.expression.for(name).tap(PLUGIN_NAME, expr => {
 							const nameIdentifier = name.includes(".")
 								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
 								: name;
@@ -60,14 +78,14 @@ class ProvidePlugin {
 								request[0],
 								nameIdentifier,
 								request.slice(1),
-								expr.range
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addDependency(dep);
 							return true;
 						});
 
-						parser.hooks.call.for(name).tap("ProvidePlugin", expr => {
+						parser.hooks.call.for(name).tap(PLUGIN_NAME, expr => {
 							const nameIdentifier = name.includes(".")
 								? `__webpack_provided_${name.replace(/\./g, "_dot_")}`
 								: name;
@@ -75,24 +93,24 @@ class ProvidePlugin {
 								request[0],
 								nameIdentifier,
 								request.slice(1),
-								expr.callee.range
+								/** @type {Range} */ (expr.callee.range)
 							);
-							dep.loc = expr.callee.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.callee.loc);
 							parser.state.module.addDependency(dep);
 							parser.walkExpressions(expr.arguments);
 							return true;
 						});
-					});
+					}
 				};
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ProvidePlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ProvidePlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ProvidePlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/RawModule.js

@@ -7,6 +7,7 @@
 
 const { OriginalSource, RawSource } = require("webpack-sources");
 const Module = require("./Module");
+const { JAVASCRIPT_MODULE_TYPE_DYNAMIC } = require("./ModuleTypeConstants");
 const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -18,10 +19,14 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./RequestShortener")} RequestShortener */
 /** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("./RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("./WebpackError")} WebpackError */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
 
@@ -32,10 +37,10 @@ class RawModule extends Module {
 	 * @param {string} source source code
 	 * @param {string} identifier unique identifier
 	 * @param {string=} readableIdentifier readable identifier
-	 * @param {ReadonlySet<string>=} runtimeRequirements runtime requirements needed for the source code
+	 * @param {ReadOnlyRuntimeRequirements=} runtimeRequirements runtime requirements needed for the source code
 	 */
 	constructor(source, identifier, readableIdentifier, runtimeRequirements) {
-		super("javascript/dynamic", null);
+		super(JAVASCRIPT_MODULE_TYPE_DYNAMIC, null);
 		this.sourceStr = source;
 		this.identifierStr = identifier || this.sourceStr;
 		this.readableIdentifierStr = readableIdentifier || this.identifierStr;
@@ -43,7 +48,7 @@ class RawModule extends Module {
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		return TYPES;
@@ -69,12 +74,14 @@ class RawModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return requestShortener.shorten(this.readableIdentifierStr);
+		return /** @type {string} */ (
+			requestShortener.shorten(this.readableIdentifierStr)
+		);
 	}
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -124,6 +131,9 @@ class RawModule extends Module {
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -135,6 +145,9 @@ class RawModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 

package/lib/RecordIdsPlugin.js

@@ -13,28 +13,28 @@ const identifierUtils = require("./util/identifier");
 /** @typedef {import("./Module")} Module */
 
 /**
- * @typedef {Object} RecordsChunks
+ * @typedef {object} RecordsChunks
  * @property {Record<string, number>=} byName
  * @property {Record<string, number>=} bySource
  * @property {number[]=} usedIds
  */
 
 /**
- * @typedef {Object} RecordsModules
+ * @typedef {object} RecordsModules
  * @property {Record<string, number>=} byIdentifier
  * @property {Record<string, number>=} bySource
  * @property {number[]=} usedIds
  */
 
 /**
- * @typedef {Object} Records
+ * @typedef {object} Records
  * @property {RecordsChunks=} chunks
  * @property {RecordsModules=} modules
  */
 
 class RecordIdsPlugin {
 	/**
-	 * @param {Object} options Options object
+	 * @param {object} options Options object
 	 * @param {boolean=} options.portableIds true, when ids need to be portable
 	 */
 	constructor(options) {
@@ -69,7 +69,7 @@ class RecordIdsPlugin {
 			compilation.hooks.recordModules.tap(
 				"RecordIdsPlugin",
 				/**
-				 * @param {Module[]} modules the modules array
+				 * @param {Iterable<Module>} modules the modules array
 				 * @param {Records} records the records object
 				 * @returns {void}
 				 */
@@ -92,7 +92,7 @@ class RecordIdsPlugin {
 			compilation.hooks.reviveModules.tap(
 				"RecordIdsPlugin",
 				/**
-				 * @param {Module[]} modules the modules array
+				 * @param {Iterable<Module>} modules the modules array
 				 * @param {Records} records the records object
 				 * @returns {void}
 				 */
@@ -166,7 +166,7 @@ class RecordIdsPlugin {
 			compilation.hooks.recordChunks.tap(
 				"RecordIdsPlugin",
 				/**
-				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Iterable<Chunk>} chunks the chunks array
 				 * @param {Records} records the records object
 				 * @returns {void}
 				 */
@@ -192,7 +192,7 @@ class RecordIdsPlugin {
 			compilation.hooks.reviveChunks.tap(
 				"RecordIdsPlugin",
 				/**
-				 * @param {Chunk[]} chunks the chunks array
+				 * @param {Iterable<Chunk>} chunks the chunks array
 				 * @param {Records} records the records object
 				 * @returns {void}
 				 */