webpack 5.99.6 → 5.99.8

package/lib/dependencies/HarmonyTopLevelThisParserPlugin.js

@@ -12,27 +12,27 @@ const HarmonyExports = require("./HarmonyExports");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "HarmonyTopLevelThisParserPlugin";
+
 class HarmonyTopLevelThisParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.expression
-			.for("this")
-			.tap("HarmonyTopLevelThisParserPlugin", node => {
-				if (!parser.scope.topLevelScope) return;
-				if (HarmonyExports.isEnabled(parser.state)) {
-					const dep = new ConstDependency(
-						"undefined",
-						/** @type {Range} */ (node.range),
-						null
-					);
-					dep.loc = /** @type {DependencyLocation} */ (node.loc);
-					parser.state.module.addPresentationalDependency(dep);
-					return true;
-				}
-			});
+		parser.hooks.expression.for("this").tap(PLUGIN_NAME, node => {
+			if (!parser.scope.topLevelScope) return;
+			if (HarmonyExports.isEnabled(parser.state)) {
+				const dep = new ConstDependency(
+					"undefined",
+					/** @type {Range} */ (node.range),
+					null
+				);
+				dep.loc = /** @type {DependencyLocation} */ (node.loc);
+				parser.state.module.addPresentationalDependency(dep);
+				return true;
+			}
+		});
 	}
 }
 

package/lib/dependencies/ImportMetaContextDependencyParserPlugin.js

@@ -52,6 +52,8 @@ function createError(msg, loc) {
 	return error;
 }
 
+const PLUGIN_NAME = "ImportMetaContextDependencyParserPlugin";
+
 module.exports = class ImportMetaContextDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
@@ -60,7 +62,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 	apply(parser) {
 		parser.hooks.evaluateIdentifier
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr =>
+			.tap(PLUGIN_NAME, expr =>
 				evaluateToIdentifier(
 					"import.meta.webpackContext",
 					"import.meta",
@@ -70,7 +72,7 @@ module.exports = class ImportMetaContextDependencyParserPlugin {
 			);
 		parser.hooks.call
 			.for("import.meta.webpackContext")
-			.tap("ImportMetaContextDependencyParserPlugin", expr => {
+			.tap(PLUGIN_NAME, expr => {
 				if (expr.arguments.length < 1 || expr.arguments.length > 2) return;
 				const [directoryNode, optionsNode] = expr.arguments;
 				if (optionsNode && optionsNode.type !== "ObjectExpression") return;

package/lib/dependencies/LoaderPlugin.js

@@ -31,6 +31,8 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  * @property {string=} baseUri target base uri
  */
 
+const PLUGIN_NAME = "LoaderPlugin";
+
 class LoaderPlugin {
 	/**
 	 * Apply the plugin
@@ -39,7 +41,7 @@ class LoaderPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"LoaderPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					LoaderDependency,
@@ -52,10 +54,10 @@ class LoaderPlugin {
 			}
 		);
 
-		compiler.hooks.compilation.tap("LoaderPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
 			const moduleGraph = compilation.moduleGraph;
 			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderPlugin",
+				PLUGIN_NAME,
 				loaderContext => {
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -12,58 +12,58 @@ const RequireContextDependency = require("./RequireContextDependency");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "RequireContextDependencyParserPlugin";
+
 module.exports = class RequireContextDependencyParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.call
-			.for("require.context")
-			.tap("RequireContextDependencyParserPlugin", expr => {
-				let regExp = /^\.\/.*$/;
-				let recursive = true;
-				/** @type {ContextMode} */
-				let mode = "sync";
-				switch (expr.arguments.length) {
-					case 4: {
-						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
-						if (!modeExpr.isString()) return;
-						mode = /** @type {ContextMode} */ (modeExpr.string);
-					}
-					// falls through
-					case 3: {
-						const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
-						if (!regExpExpr.isRegExp()) return;
-						regExp = /** @type {RegExp} */ (regExpExpr.regExp);
-					}
-					// falls through
-					case 2: {
-						const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
-						if (!recursiveExpr.isBoolean()) return;
-						recursive = /** @type {boolean} */ (recursiveExpr.bool);
-					}
-					// falls through
-					case 1: {
-						const requestExpr = parser.evaluateExpression(expr.arguments[0]);
-						if (!requestExpr.isString()) return;
-						const dep = new RequireContextDependency(
-							{
-								request: /** @type {string} */ (requestExpr.string),
-								recursive,
-								regExp,
-								mode,
-								category: "commonjs"
-							},
-							/** @type {Range} */
-							(expr.range)
-						);
-						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-						dep.optional = Boolean(parser.scope.inTry);
-						parser.state.current.addDependency(dep);
-						return true;
-					}
+		parser.hooks.call.for("require.context").tap(PLUGIN_NAME, expr => {
+			let regExp = /^\.\/.*$/;
+			let recursive = true;
+			/** @type {ContextMode} */
+			let mode = "sync";
+			switch (expr.arguments.length) {
+				case 4: {
+					const modeExpr = parser.evaluateExpression(expr.arguments[3]);
+					if (!modeExpr.isString()) return;
+					mode = /** @type {ContextMode} */ (modeExpr.string);
+				}
+				// falls through
+				case 3: {
+					const regExpExpr = parser.evaluateExpression(expr.arguments[2]);
+					if (!regExpExpr.isRegExp()) return;
+					regExp = /** @type {RegExp} */ (regExpExpr.regExp);
+				}
+				// falls through
+				case 2: {
+					const recursiveExpr = parser.evaluateExpression(expr.arguments[1]);
+					if (!recursiveExpr.isBoolean()) return;
+					recursive = /** @type {boolean} */ (recursiveExpr.bool);
+				}
+				// falls through
+				case 1: {
+					const requestExpr = parser.evaluateExpression(expr.arguments[0]);
+					if (!requestExpr.isString()) return;
+					const dep = new RequireContextDependency(
+						{
+							request: /** @type {string} */ (requestExpr.string),
+							recursive,
+							regExp,
+							mode,
+							category: "commonjs"
+						},
+						/** @type {Range} */
+						(expr.range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					dep.optional = Boolean(parser.scope.inTry);
+					parser.state.current.addDependency(dep);
+					return true;
 				}
-			});
+			}
+		});
 	}
 };

package/lib/dependencies/RequireContextPlugin.js

@@ -80,7 +80,8 @@ class RequireContextPlugin {
 							cachedSetProperty(
 								options.resolveOptions || EMPTY_RESOLVE_OPTIONS,
 								"dependencyType",
-								/** @type {string} */ (options.category)
+								/** @type {string} */
+								(options.category)
 							)
 						).options;
 

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -17,128 +17,122 @@ const getFunctionExpression = require("./getFunctionExpression");
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
+const PLUGIN_NAME = "RequireEnsureDependenciesBlockParserPlugin";
+
 module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 	/**
 	 * @param {JavascriptParser} parser the parser
 	 * @returns {void}
 	 */
 	apply(parser) {
-		parser.hooks.call
-			.for("require.ensure")
-			.tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
-				/** @type {string | GroupOptions | null} */
-				let chunkName = null;
-				let errorExpressionArg = null;
-				let errorExpression = null;
-				switch (expr.arguments.length) {
-					case 4: {
-						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
+		parser.hooks.call.for("require.ensure").tap(PLUGIN_NAME, expr => {
+			/** @type {string | GroupOptions | null} */
+			let chunkName = null;
+			let errorExpressionArg = null;
+			let errorExpression = null;
+			switch (expr.arguments.length) {
+				case 4: {
+					const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
+					if (!chunkNameExpr.isString()) return;
+					chunkName =
+						/** @type {string} */
+						(chunkNameExpr.string);
+				}
+				// falls through
+				case 3: {
+					errorExpressionArg = expr.arguments[2];
+					errorExpression = getFunctionExpression(errorExpressionArg);
+
+					if (!errorExpression && !chunkName) {
+						const chunkNameExpr = parser.evaluateExpression(expr.arguments[2]);
 						if (!chunkNameExpr.isString()) return;
 						chunkName =
 							/** @type {string} */
 							(chunkNameExpr.string);
 					}
-					// falls through
-					case 3: {
-						errorExpressionArg = expr.arguments[2];
-						errorExpression = getFunctionExpression(errorExpressionArg);
+				}
+				// falls through
+				case 2: {
+					const dependenciesExpr = parser.evaluateExpression(expr.arguments[0]);
+					const dependenciesItems = /** @type {BasicEvaluatedExpression[]} */ (
+						dependenciesExpr.isArray()
+							? dependenciesExpr.items
+							: [dependenciesExpr]
+					);
+					const successExpressionArg = expr.arguments[1];
+					const successExpression = getFunctionExpression(successExpressionArg);
 
-						if (!errorExpression && !chunkName) {
-							const chunkNameExpr = parser.evaluateExpression(
-								expr.arguments[2]
-							);
-							if (!chunkNameExpr.isString()) return;
-							chunkName =
-								/** @type {string} */
-								(chunkNameExpr.string);
-						}
+					if (successExpression) {
+						parser.walkExpressions(successExpression.expressions);
+					}
+					if (errorExpression) {
+						parser.walkExpressions(errorExpression.expressions);
 					}
-					// falls through
-					case 2: {
-						const dependenciesExpr = parser.evaluateExpression(
-							expr.arguments[0]
-						);
-						const dependenciesItems =
-							/** @type {BasicEvaluatedExpression[]} */ (
-								dependenciesExpr.isArray()
-									? dependenciesExpr.items
-									: [dependenciesExpr]
-							);
-						const successExpressionArg = expr.arguments[1];
-						const successExpression =
-							getFunctionExpression(successExpressionArg);
-
-						if (successExpression) {
-							parser.walkExpressions(successExpression.expressions);
-						}
-						if (errorExpression) {
-							parser.walkExpressions(errorExpression.expressions);
-						}
 
-						const depBlock = new RequireEnsureDependenciesBlock(
-							chunkName,
-							/** @type {DependencyLocation} */
-							(expr.loc)
-						);
-						const errorCallbackExists =
-							expr.arguments.length === 4 ||
-							(!chunkName && expr.arguments.length === 3);
-						const dep = new RequireEnsureDependency(
-							/** @type {Range} */ (expr.range),
-							/** @type {Range} */ (expr.arguments[1].range),
-							errorCallbackExists &&
-								/** @type {Range} */ (expr.arguments[2].range)
-						);
-						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-						depBlock.addDependency(dep);
-						const old = parser.state.current;
-						parser.state.current = /** @type {TODO} */ (depBlock);
-						try {
-							let failed = false;
-							parser.inScope([], () => {
-								for (const ee of dependenciesItems) {
-									if (ee.isString()) {
-										const ensureDependency = new RequireEnsureItemDependency(
-											/** @type {string} */ (ee.string)
-										);
-										ensureDependency.loc =
-											/** @type {DependencyLocation} */
-											(expr.loc);
-										depBlock.addDependency(ensureDependency);
-									} else {
-										failed = true;
-									}
-								}
-							});
-							if (failed) {
-								return;
-							}
-							if (successExpression) {
-								if (successExpression.fn.body.type === "BlockStatement") {
-									parser.walkStatement(successExpression.fn.body);
+					const depBlock = new RequireEnsureDependenciesBlock(
+						chunkName,
+						/** @type {DependencyLocation} */
+						(expr.loc)
+					);
+					const errorCallbackExists =
+						expr.arguments.length === 4 ||
+						(!chunkName && expr.arguments.length === 3);
+					const dep = new RequireEnsureDependency(
+						/** @type {Range} */ (expr.range),
+						/** @type {Range} */ (expr.arguments[1].range),
+						errorCallbackExists &&
+							/** @type {Range} */ (expr.arguments[2].range)
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+					depBlock.addDependency(dep);
+					const old = parser.state.current;
+					parser.state.current = /** @type {TODO} */ (depBlock);
+					try {
+						let failed = false;
+						parser.inScope([], () => {
+							for (const ee of dependenciesItems) {
+								if (ee.isString()) {
+									const ensureDependency = new RequireEnsureItemDependency(
+										/** @type {string} */ (ee.string)
+									);
+									ensureDependency.loc =
+										/** @type {DependencyLocation} */
+										(expr.loc);
+									depBlock.addDependency(ensureDependency);
 								} else {
-									parser.walkExpression(successExpression.fn.body);
+									failed = true;
 								}
 							}
-							old.addBlock(depBlock);
-						} finally {
-							parser.state.current = old;
-						}
-						if (!successExpression) {
-							parser.walkExpression(successExpressionArg);
+						});
+						if (failed) {
+							return;
 						}
-						if (errorExpression) {
-							if (errorExpression.fn.body.type === "BlockStatement") {
-								parser.walkStatement(errorExpression.fn.body);
+						if (successExpression) {
+							if (successExpression.fn.body.type === "BlockStatement") {
+								parser.walkStatement(successExpression.fn.body);
 							} else {
-								parser.walkExpression(errorExpression.fn.body);
+								parser.walkExpression(successExpression.fn.body);
 							}
-						} else if (errorExpressionArg) {
-							parser.walkExpression(errorExpressionArg);
 						}
-						return true;
+						old.addBlock(depBlock);
+					} finally {
+						parser.state.current = old;
+					}
+					if (!successExpression) {
+						parser.walkExpression(successExpressionArg);
+					}
+					if (errorExpression) {
+						if (errorExpression.fn.body.type === "BlockStatement") {
+							parser.walkStatement(errorExpression.fn.body);
+						} else {
+							parser.walkExpression(errorExpression.fn.body);
+						}
+					} else if (errorExpressionArg) {
+						parser.walkExpression(errorExpressionArg);
 					}
+					return true;
 				}
-			});
+			}
+		});
 	}
 };

package/lib/dependencies/WorkerPlugin.js

@@ -34,6 +34,7 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("../../declarations/WebpackOptions").ChunkLoading} ChunkLoading */
+/** @typedef {import("../../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../../declarations/WebpackOptions").OutputModule} OutputModule */
 /** @typedef {import("../../declarations/WebpackOptions").WasmLoading} WasmLoading */
@@ -47,7 +48,6 @@ 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 */
 
 /**
@@ -376,7 +376,7 @@ class WorkerPlugin {
 								parser.state.module.identifier()
 							)}|${i}`;
 							const hash = createHash(
-								/** @type {Algorithm} */
+								/** @type {HashFunction} */
 								(compilation.outputOptions.hashFunction)
 							);
 							hash.update(name);

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -12,6 +12,8 @@ const ModuleChunkLoadingRuntimeModule = require("./ModuleChunkLoadingRuntimeModu
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "ModuleChunkLoadingPlugin";
+
 class ModuleChunkLoadingPlugin {
 	/**
 	 * Apply the plugin
@@ -19,88 +21,85 @@ class ModuleChunkLoadingPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"ModuleChunkLoadingPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				/**
-				 * @param {Chunk} chunk chunk to check
-				 * @returns {boolean} true, when the plugin is enabled for the chunk
-				 */
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === "import";
-				};
-				const onceForChunkSet = new WeakSet();
-				/**
-				 * @param {Chunk} chunk chunk to check
-				 * @param {Set<string>} set runtime requirements
-				 */
-				const handler = (chunk, set) => {
-					if (onceForChunkSet.has(chunk)) return;
-					onceForChunkSet.add(chunk);
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			/**
+			 * @param {Chunk} chunk chunk to check
+			 * @returns {boolean} true, when the plugin is enabled for the chunk
+			 */
+			const isEnabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === "import";
+			};
+			const onceForChunkSet = new WeakSet();
+			/**
+			 * @param {Chunk} chunk chunk to check
+			 * @param {Set<string>} set runtime requirements
+			 */
+			const handler = (chunk, set) => {
+				if (onceForChunkSet.has(chunk)) return;
+				onceForChunkSet.add(chunk);
+				if (!isEnabledForChunk(chunk)) return;
+				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				set.add(RuntimeGlobals.hasOwnProperty);
+				compilation.addRuntimeModule(
+					chunk,
+					new ModuleChunkLoadingRuntimeModule(set)
+				);
+			};
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.baseURI)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.externalInstallChunk)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.onChunksLoaded)
+				.tap(PLUGIN_NAME, handler);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.externalInstallChunk)
+				.tap(PLUGIN_NAME, (chunk, set) => {
 					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-					set.add(RuntimeGlobals.hasOwnProperty);
 					compilation.addRuntimeModule(
 						chunk,
-						new ModuleChunkLoadingRuntimeModule(set)
+						new ExportWebpackRequireRuntimeModule()
 					);
-				};
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.baseURI)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.onChunksLoaded)
-					.tap("ModuleChunkLoadingPlugin", handler);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.externalInstallChunk)
-					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						compilation.addRuntimeModule(
-							chunk,
-							new ExportWebpackRequireRuntimeModule()
-						);
-					});
+				});
 
-				// We need public path only when we prefetch/preload chunk or public path is not `auto`
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.prefetchChunkHandlers)
-					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-					});
+			// We need public path only when we prefetch/preload chunk or public path is not `auto`
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.prefetchChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.publicPath);
+				});
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.preloadChunkHandlers)
-					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.publicPath);
-					});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.preloadChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.publicPath);
+				});
 
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.ensureChunkHandlers)
-					.tap("ModuleChunkLoadingPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.ensureChunkHandlers)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
 
-						if (compilation.outputOptions.publicPath !== "auto") {
-							set.add(RuntimeGlobals.publicPath);
-						}
+					if (compilation.outputOptions.publicPath !== "auto") {
+						set.add(RuntimeGlobals.publicPath);
+					}
 
-						set.add(RuntimeGlobals.getChunkScriptFilename);
-					});
-			}
-		);
+					set.add(RuntimeGlobals.getChunkScriptFilename);
+				});
+		});
 	}
 }
 

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -69,7 +69,6 @@ module.exports = function () {
 					me.children.push(request);
 				}
 			} else {
-				// eslint-disable-next-line no-console
 				console.warn(
 					"[HMR] unexpected require(" +
 						request +

package/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -109,7 +109,6 @@ module.exports = function () {
 		var appliedUpdate = {};
 
 		var warnUnexpectedRequire = function warnUnexpectedRequire(module) {
-			// eslint-disable-next-line no-console
 			console.warn(
 				"[HMR] unexpected require(" + module.id + ") to disposed module"
 			);
@@ -118,7 +117,6 @@ module.exports = function () {
 		for (var moduleId in currentUpdate) {
 			if ($hasOwnProperty$(currentUpdate, moduleId)) {
 				var newModuleFactory = currentUpdate[moduleId];
-				/** @type {TODO} */
 				var result = newModuleFactory
 					? getAffectedModuleEffects(moduleId)
 					: {