webpack 5.92.1 → 5.94.0

package/lib/dependencies/WorkerPlugin.js

@@ -45,15 +45,14 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../util/createHash").Algorithm} Algorithm */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
 
 /**
  * @param {NormalModule} module module
  * @returns {string} url
  */
-const getUrl = module => {
-	return pathToFileURL(module.resource).toString();
-};
+const getUrl = module => pathToFileURL(module.resource).toString();
 
 const WorkerSpecifierTag = Symbol("worker specifier tag");
 
@@ -82,6 +81,7 @@ class WorkerPlugin {
 		this._module = module;
 		this._workerPublicPath = workerPublicPath;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -258,7 +258,7 @@ class WorkerPlugin {
 						}
 
 						/** @type {EntryOptions} */
-						let entryOptions = {};
+						const entryOptions = {};
 
 						if (importOptions) {
 							if (importOptions.webpackIgnore !== undefined) {
@@ -269,10 +269,8 @@ class WorkerPlugin {
 											/** @type {DependencyLocation} */ (expr.loc)
 										)
 									);
-								} else {
-									if (importOptions.webpackIgnore) {
-										return false;
-									}
+								} else if (importOptions.webpackIgnore) {
+									return false;
 								}
 							}
 							if (importOptions.webpackEntryOptions !== undefined) {
@@ -316,16 +314,19 @@ class WorkerPlugin {
 						}
 
 						if (entryOptions.runtime === undefined) {
-							let i = workerIndexMap.get(parser.state) || 0;
+							const i = workerIndexMap.get(parser.state) || 0;
 							workerIndexMap.set(parser.state, i + 1);
-							let name = `${cachedContextify(
+							const name = `${cachedContextify(
 								parser.state.module.identifier()
 							)}|${i}`;
-							const hash = createHash(compilation.outputOptions.hashFunction);
-							hash.update(name);
-							const digest = /** @type {string} */ (
-								hash.digest(compilation.outputOptions.hashDigest)
+							const hash = createHash(
+								/** @type {Algorithm} */
+								(compilation.outputOptions.hashFunction)
 							);
+							hash.update(name);
+							const digest =
+								/** @type {string} */
+								(hash.digest(compilation.outputOptions.hashDigest));
 							entryOptions.runtime = digest.slice(
 								0,
 								compilation.outputOptions.hashDigestLength
@@ -394,15 +395,13 @@ class WorkerPlugin {
 							dep2.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep1);
 							parser.state.module.addPresentationalDependency(dep2);
-						} else if (insertType === "argument") {
-							if (this._module) {
-								const dep = new ConstDependency(
-									', { type: "module" }',
-									insertLocation
-								);
-								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-								parser.state.module.addPresentationalDependency(dep);
-							}
+						} else if (insertType === "argument" && this._module) {
+							const dep = new ConstDependency(
+								', { type: "module" }',
+								insertLocation
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
 						}
 
 						parser.walkExpression(expr.callee);
@@ -482,7 +481,9 @@ class WorkerPlugin {
 					};
 					for (const item of options) {
 						if (item === "...") {
-							DEFAULT_SYNTAX.forEach(processItem);
+							for (const itemFromDefault of DEFAULT_SYNTAX) {
+								processItem(itemFromDefault);
+							}
 						} else processItem(item);
 					}
 				};

package/lib/dependencies/processExportInfo.js

@@ -10,9 +10,11 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/** @typedef {string[][]} ReferencedExports */
+
 /**
  * @param {RuntimeSpec} runtime the runtime
- * @param {string[][]} referencedExports list of referenced exports, will be added to
+ * @param {ReferencedExports} referencedExports list of referenced exports, will be added to
  * @param {string[]} prefix export prefix
  * @param {ExportInfo=} exportInfo the export info
  * @param {boolean} defaultPointsToSelf when true, using default will reference itself

package/lib/electron/ElectronTargetPlugin.js

@@ -16,6 +16,7 @@ class ElectronTargetPlugin {
 	constructor(context) {
 		this._context = context;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -16,6 +16,7 @@ const {
 	getChunkFilenameTemplate
 } = require("../javascript/JavascriptModulesPlugin");
 const { updateHashForEntryStartup } = require("../javascript/StartupHelpers");
+const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
@@ -57,9 +58,9 @@ class ModuleChunkFormatPlugin {
 						} else {
 							source.add(`export const id = ${JSON.stringify(chunk.id)};\n`);
 							source.add(`export const ids = ${JSON.stringify(chunk.ids)};\n`);
-							source.add(`export const modules = `);
+							source.add("export const modules = ");
 							source.add(modules);
-							source.add(`;\n`);
+							source.add(";\n");
 							const runtimeModules =
 								chunkGraph.getChunkRuntimeModulesInOrder(chunk);
 							if (runtimeModules.length > 0) {
@@ -86,11 +87,9 @@ class ModuleChunkFormatPlugin {
 											contentHashType: "javascript"
 										}
 									)
+									.replace(/^\/+/g, "")
 									.split("/");
 
-								// remove filename, we only need the directory
-								currentOutputName.pop();
-
 								/**
 								 * @param {Chunk} chunk the chunk
 								 * @returns {string} the relative path
@@ -104,26 +103,26 @@ class ModuleChunkFormatPlugin {
 												compilation.outputOptions
 											),
 											{
-												chunk: chunk,
+												chunk,
 												contentHashType: "javascript"
 											}
 										)
+										.replace(/^\/+/g, "")
 										.split("/");
 
-									// remove common parts
+									// remove common parts except filename
 									while (
-										baseOutputName.length > 0 &&
-										chunkOutputName.length > 0 &&
+										baseOutputName.length > 1 &&
+										chunkOutputName.length > 1 &&
 										baseOutputName[0] === chunkOutputName[0]
 									) {
 										baseOutputName.shift();
 										chunkOutputName.shift();
 									}
+									const last = chunkOutputName.join("/");
 									// create final path
 									return (
-										(baseOutputName.length > 0
-											? "../".repeat(baseOutputName.length)
-											: "./") + chunkOutputName.join("/")
+										getUndoPath(baseOutputName.join("/"), last, true) + last
 									);
 								};
 

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -17,6 +17,7 @@ const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const { getUndoPath } = require("../util/identifier");
 
+/** @typedef {import("../../declarations/WebpackOptions").Environment} Environment */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
@@ -87,9 +88,12 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const chunk = /** @type {Chunk} */ (this.chunk);
+		const environment =
+			/** @type {Environment} */
+			(compilation.outputOptions.environment);
 		const {
 			runtimeTemplate,
-			outputOptions: { environment, importFunctionName, crossOriginLoading }
+			outputOptions: { importFunctionName, crossOriginLoading }
 		} = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
@@ -219,10 +223,10 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 														]
 													)});`,
 													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve]`,
+														"installedChunkData = installedChunks[chunkId] = [resolve]",
 														"resolve"
 													)})])`,
-													`promises.push(installedChunkData[1] = promise);`
+													"promises.push(installedChunkData[1] = promise);"
 												]),
 												hasJsMatcher === true
 													? "}"

package/lib/formatLocation.js

@@ -48,9 +48,8 @@ const formatLocation = loc => {
 				typeof loc.end.column !== "number"
 			) {
 				return `${loc.start.line}-${loc.end.line}`;
-			} else {
-				return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
 			}
+			return `${formatPosition(loc.start)}-${formatPosition(loc.end)}`;
 		}
 		if ("start" in loc && loc.start) {
 			return formatPosition(loc.start);

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -201,7 +201,7 @@ module.exports = function () {
 				if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
 			},
 
-			//inherit from previous dispose call
+			// inherit from previous dispose call
 			data: currentModuleData[moduleId]
 		};
 		currentChildModule = undefined;
@@ -293,11 +293,10 @@ module.exports = function () {
 						return waitForBlockingPromises(function () {
 							if (applyOnUpdate) {
 								return internalApply(applyOnUpdate);
-							} else {
-								return setStatus("ready").then(function () {
-									return updatedModules;
-								});
 							}
+							return setStatus("ready").then(function () {
+								return updatedModules;
+							});
 						});
 					});
 				});

package/lib/hmr/HotModuleReplacementRuntimeModule.js

@@ -13,6 +13,7 @@ class HotModuleReplacementRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("hot module replacement", RuntimeModule.STAGE_BASIC);
 	}
+
 	/**
 	 * @returns {string | null} runtime code
 	 */

package/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -117,15 +117,12 @@ module.exports = function () {
 			if ($hasOwnProperty$(currentUpdate, moduleId)) {
 				var newModuleFactory = currentUpdate[moduleId];
 				/** @type {TODO} */
-				var result;
-				if (newModuleFactory) {
-					result = getAffectedModuleEffects(moduleId);
-				} else {
-					result = {
-						type: "disposed",
-						moduleId: moduleId
-					};
-				}
+				var result = newModuleFactory
+					? getAffectedModuleEffects(moduleId)
+					: {
+							type: "disposed",
+							moduleId: moduleId
+						};
 				/** @type {Error|false} */
 				var abortError = false;
 				var doApply = false;
@@ -376,17 +373,17 @@ module.exports = function () {
 									moduleId: moduleId,
 									module: $moduleCache$[moduleId]
 								});
-							} catch (err2) {
+							} catch (err1) {
 								if (options.onErrored) {
 									options.onErrored({
 										type: "self-accept-error-handler-errored",
 										moduleId: moduleId,
-										error: err2,
+										error: err1,
 										originalError: err
 									});
 								}
 								if (!options.ignoreErrored) {
-									reportError(err2);
+									reportError(err1);
 									reportError(err);
 								}
 							}

package/lib/hmr/LazyCompilationPlugin.js

@@ -37,10 +37,12 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
+/** @typedef {{ client: string, data: string, active: boolean }} ModuleResult */
+
 /**
  * @typedef {object} BackendApi
- * @property {function(Error=): void} dispose
- * @property {function(Module): { client: string, data: string, active: boolean }} module
+ * @property {function(function((Error | null)=) : void): void} dispose
+ * @property {function(Module): ModuleResult} module
  */
 
 const HMR_DEPENDENCY_TYPES = new Set([
@@ -53,7 +55,7 @@ const HMR_DEPENDENCY_TYPES = new Set([
 /**
  * @param {undefined|string|RegExp|Function} test test option
  * @param {Module} module the module
- * @returns {boolean} true, if the module should be selected
+ * @returns {boolean | null | string} true, if the module should be selected
  */
 const checkTest = (test, module) => {
 	if (test === undefined) return true;
@@ -74,6 +76,9 @@ const checkTest = (test, module) => {
 const TYPES = new Set(["javascript"]);
 
 class LazyCompilationDependency extends Dependency {
+	/**
+	 * @param {LazyCompilationProxyModule} proxyModule proxy module
+	 */
 	constructor(proxyModule) {
 		super();
 		this.proxyModule = proxyModule;
@@ -98,6 +103,14 @@ class LazyCompilationDependency extends Dependency {
 registerNotSerializable(LazyCompilationDependency);
 
 class LazyCompilationProxyModule extends Module {
+	/**
+	 * @param {string} context context
+	 * @param {Module} originalModule an original module
+	 * @param {string} request request
+	 * @param {ModuleResult["client"]} client client
+	 * @param {ModuleResult["data"]} data data
+	 * @param {ModuleResult["active"]} active true when active, otherwise false
+	 */
 	constructor(context, originalModule, request, client, data, active) {
 		super(
 			WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY,
@@ -229,13 +242,13 @@ class LazyCompilationProxyModule extends Module {
 		]);
 		const keepActive = Template.asString([
 			`var dispose = client.keepAlive({ data: data, active: ${JSON.stringify(
-				!!block
+				Boolean(block)
 			)}, module: module, onError: onError });`
 		]);
 		let source;
 		if (block) {
 			const dep = block.dependencies[0];
-			const module = moduleGraph.getModule(dep);
+			const module = /** @type {Module} */ (moduleGraph.getModule(dep));
 			source = Template.asString([
 				client,
 				`module.exports = ${runtimeTemplate.moduleNamespacePromise({
@@ -264,7 +277,7 @@ class LazyCompilationProxyModule extends Module {
 			source = Template.asString([
 				client,
 				"var resolveSelf, onError;",
-				`module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });`,
+				"module.exports = new Promise(function(resolve, reject) { resolveSelf = resolve; onError = reject; });",
 				"if (module.hot) {",
 				Template.indent([
 					"module.hot.accept();",
@@ -297,9 +310,8 @@ class LazyCompilationProxyModule extends Module {
 registerNotSerializable(LazyCompilationProxyModule);
 
 class LazyCompilationDependencyFactory extends ModuleFactory {
-	constructor(factory) {
+	constructor() {
 		super();
-		this._factory = factory;
 	}
 
 	/**
@@ -320,10 +332,10 @@ class LazyCompilationDependencyFactory extends ModuleFactory {
 class LazyCompilationPlugin {
 	/**
 	 * @param {object} options options
-	 * @param {(function(Compiler, function(Error?, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
+	 * @param {(function(Compiler, function(Error=, BackendApi?): void): void) | function(Compiler): Promise<BackendApi>} options.backend the backend
 	 * @param {boolean} options.entries true, when entries are lazy compiled
 	 * @param {boolean} options.imports true, when import() modules are lazy compiled
-	 * @param {RegExp | string | (function(Module): boolean)} options.test additional filter for lazy compiled entrypoint modules
+	 * @param {RegExp | string | (function(Module): boolean) | undefined} options.test additional filter for lazy compiled entrypoint modules
 	 */
 	constructor({ backend, entries, imports, test }) {
 		this.backend = backend;
@@ -331,12 +343,14 @@ class LazyCompilationPlugin {
 		this.imports = imports;
 		this.test = test;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		/** @type {BackendApi} */
 		let backend;
 		compiler.hooks.beforeCompile.tapAsync(
 			"LazyCompilationPlugin",
@@ -344,7 +358,7 @@ class LazyCompilationPlugin {
 				if (backend !== undefined) return callback();
 				const promise = this.backend(compiler, (err, result) => {
 					if (err) return callback(err);
-					backend = result;
+					backend = /** @type {BackendApi} */ (result);
 					callback();
 				});
 				if (promise && promise.then) {
@@ -370,7 +384,8 @@ class LazyCompilationPlugin {
 							// an import() or not
 							const hmrDep = resolveData.dependencies[0];
 							const originModule =
-								compilation.moduleGraph.getParentModule(hmrDep);
+								/** @type {Module} */
+								(compilation.moduleGraph.getParentModule(hmrDep));
 							const isReferringToDynamicImport = originModule.blocks.some(
 								block =>
 									block.dependencies.some(

package/lib/hmr/lazyCompilationBackend.js

@@ -5,15 +5,22 @@
 
 "use strict";
 
+/** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").RequestListener} RequestListener */
 /** @typedef {import("http").ServerOptions} HttpServerOptions */
+/** @typedef {import("http").ServerResponse} ServerResponse */
 /** @typedef {import("https").ServerOptions} HttpsServerOptions */
+/** @typedef {import("net").AddressInfo} AddressInfo */
+/** @typedef {import("net").Server} Server */
 /** @typedef {import("../../declarations/WebpackOptions").LazyCompilationDefaultBackendOptions} LazyCompilationDefaultBackendOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("./LazyCompilationPlugin").BackendApi} BackendApi */
 
 /**
  * @callback BackendHandler
  * @param {Compiler} compiler compiler
- * @param {function((Error | null)=, any=): void} callback callback
+ * @param {function(Error | null, BackendApi=): void} callback callback
  * @returns {void}
  */
 
@@ -36,8 +43,13 @@ module.exports = options => (compiler, callback) => {
 			? options.server
 			: (() => {
 					const http = isHttps ? require("https") : require("http");
-					return http.createServer.bind(http, options.server);
+					return http.createServer.bind(
+						http,
+						/** @type {HttpServerOptions | HttpsServerOptions} */
+						(options.server)
+					);
 				})();
+	/** @type {function(Server): void} */
 	const listen =
 		typeof options.listen === "function"
 			? options.listen
@@ -50,7 +62,9 @@ module.exports = options => (compiler, callback) => {
 
 	const protocol = options.protocol || (isHttps ? "https" : "http");
 
+	/** @type {RequestListener} */
 	const requestListener = (req, res) => {
+		if (req.url === undefined) return;
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
 			setTimeout(() => {
@@ -85,7 +99,7 @@ module.exports = options => (compiler, callback) => {
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
 	};
 
-	const server = /** @type {import("net").Server} */ (createServer());
+	const server = /** @type {Server} */ (createServer());
 	server.on("request", requestListener);
 
 	let isClosing = false;
@@ -101,43 +115,53 @@ module.exports = options => (compiler, callback) => {
 	server.on("clientError", e => {
 		if (e.message !== "Server is disposing") logger.warn(e);
 	});
-	server.on("listening", err => {
-		if (err) return callback(err);
-		const addr = server.address();
-		if (typeof addr === "string") throw new Error("addr must not be a string");
-		const urlBase =
-			addr.address === "::" || addr.address === "0.0.0.0"
-				? `${protocol}://localhost:${addr.port}`
-				: addr.family === "IPv6"
-					? `${protocol}://[${addr.address}]:${addr.port}`
-					: `${protocol}://${addr.address}:${addr.port}`;
-		logger.log(
-			`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
-		);
-		callback(null, {
-			dispose(callback) {
-				isClosing = true;
-				// Removing the listener is a workaround for a memory leak in node.js
-				server.off("request", requestListener);
-				server.close(err => {
-					callback(err);
-				});
-				for (const socket of sockets) {
-					socket.destroy(new Error("Server is disposing"));
+
+	server.on(
+		"listening",
+		/**
+		 * @param {Error} err error
+		 * @returns {void}
+		 */
+		err => {
+			if (err) return callback(err);
+			const _addr = server.address();
+			if (typeof _addr === "string")
+				throw new Error("addr must not be a string");
+			const addr = /** @type {AddressInfo} */ (_addr);
+			const urlBase =
+				addr.address === "::" || addr.address === "0.0.0.0"
+					? `${protocol}://localhost:${addr.port}`
+					: addr.family === "IPv6"
+						? `${protocol}://[${addr.address}]:${addr.port}`
+						: `${protocol}://${addr.address}:${addr.port}`;
+			logger.log(
+				`Server-Sent-Events server for lazy compilation open at ${urlBase}.`
+			);
+			callback(null, {
+				dispose(callback) {
+					isClosing = true;
+					// Removing the listener is a workaround for a memory leak in node.js
+					server.off("request", requestListener);
+					server.close(err => {
+						callback(err);
+					});
+					for (const socket of sockets) {
+						socket.destroy(new Error("Server is disposing"));
+					}
+				},
+				module(originalModule) {
+					const key = `${encodeURIComponent(
+						originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
+					).replace(/%(2F|3A|24|26|2B|2C|3B|3D)/g, decodeURIComponent)}`;
+					const active = activeModules.get(key) > 0;
+					return {
+						client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
+						data: key,
+						active
+					};
 				}
-			},
-			module(originalModule) {
-				const key = `${encodeURIComponent(
-					originalModule.identifier().replace(/\\/g, "/").replace(/@/g, "_")
-				).replace(/%(2F|3A|24|26|2B|2C|3B|3D|3A)/g, decodeURIComponent)}`;
-				const active = activeModules.get(key) > 0;
-				return {
-					client: `${options.client}?${encodeURIComponent(urlBase + prefix)}`,
-					data: key,
-					active
-				};
-			}
-		});
-	});
+			});
+		}
+	);
 	listen(server);
 };

package/lib/ids/ChunkModuleIdRangePlugin.js

@@ -70,9 +70,7 @@ class ChunkModuleIdRangePlugin {
 					chunkModules = chunkGraph.getOrderedChunkModules(chunk, cmpFn);
 				} else {
 					chunkModules = Array.from(modules)
-						.filter(m => {
-							return chunkGraph.isModuleInChunk(m, chunk);
-						})
+						.filter(m => chunkGraph.isModuleInChunk(m, chunk))
 						.sort(compareModulesByPreOrderIndexOrIdentifier(moduleGraph));
 				}
 

package/lib/ids/DeterministicChunkIdsPlugin.js

@@ -51,9 +51,7 @@ class DeterministicChunkIdsPlugin {
 
 						const usedIds = getUsedChunkIds(compilation);
 						assignDeterministicIds(
-							Array.from(chunks).filter(chunk => {
-								return chunk.id === null;
-							}),
+							Array.from(chunks).filter(chunk => chunk.id === null),
 							chunk =>
 								getFullChunkName(chunk, chunkGraph, context, compiler.root),
 							compareNatural,
@@ -65,7 +63,7 @@ class DeterministicChunkIdsPlugin {
 								chunk.ids = [id];
 								return true;
 							},
-							[Math.pow(10, maxLength)],
+							[10 ** maxLength],
 							10,
 							usedIds.size
 						);

package/lib/ids/DeterministicModuleIdsPlugin.js

@@ -77,7 +77,7 @@ class DeterministicModuleIdsPlugin {
 							chunkGraph.setModuleId(module, id);
 							return true;
 						},
-						[Math.pow(10, maxLength)],
+						[10 ** maxLength],
 						fixedLength ? 0 : 10,
 						usedIds.size,
 						salt

package/lib/ids/HashedModuleIdsPlugin.js

@@ -64,7 +64,11 @@ class HashedModuleIdsPlugin {
 				);
 				for (const module of modulesInNaturalOrder) {
 					const ident = getFullModuleName(module, context, compiler.root);
-					const hash = createHash(options.hashFunction);
+					const hash = createHash(
+						/** @type {NonNullable<HashedModuleIdsPluginOptions["hashFunction"]>} */ (
+							options.hashFunction
+						)
+					);
 					hash.update(ident || "");
 					const hashId = /** @type {string} */ (
 						hash.digest(options.hashDigest)