webpack 5.97.1 → 5.104.1

package/lib/IgnorePlugin.js

@@ -12,9 +12,10 @@ const createSchemaValidation = require("./util/create-schema-validation");
 /** @typedef {import("../declarations/plugins/IgnorePlugin").IgnorePluginOptions} IgnorePluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./NormalModuleFactory").ResolveData} ResolveData */
+/** @typedef {import("./ContextModuleFactory").BeforeContextResolveData} BeforeContextResolveData */
 
 const validate = createSchemaValidation(
-	require("../schemas/plugins/IgnorePlugin.check.js"),
+	require("../schemas/plugins/IgnorePlugin.check"),
 	() => require("../schemas/plugins/IgnorePlugin.json"),
 	{
 		name: "Ignore Plugin",
@@ -22,6 +23,10 @@ const validate = createSchemaValidation(
 	}
 );
 
+/** @typedef {(resource: string, context: string) => boolean} CheckResourceFn */
+
+const PLUGIN_NAME = "IgnorePlugin";
+
 class IgnorePlugin {
 	/**
 	 * @param {IgnorePluginOptions} options IgnorePlugin options
@@ -29,18 +34,13 @@ class IgnorePlugin {
 	constructor(options) {
 		validate(options);
 		this.options = options;
-
-		/**
-		 * @private
-		 * @type {Function}
-		 */
 		this.checkIgnore = this.checkIgnore.bind(this);
 	}
 
 	/**
 	 * Note that if "contextRegExp" is given, both the "resourceRegExp" and "contextRegExp" have to match.
-	 * @param {ResolveData} resolveData resolve data
-	 * @returns {false|undefined} returns false when the request should be ignored, otherwise undefined
+	 * @param {ResolveData | BeforeContextResolveData} resolveData resolve data
+	 * @returns {false | undefined} returns false when the request should be ignored, otherwise undefined
 	 */
 	checkIgnore(resolveData) {
 		if (
@@ -74,8 +74,8 @@ class IgnorePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.normalModuleFactory.tap("IgnorePlugin", nmf => {
-			nmf.hooks.beforeResolve.tap("IgnorePlugin", resolveData => {
+		compiler.hooks.normalModuleFactory.tap(PLUGIN_NAME, (nmf) => {
+			nmf.hooks.beforeResolve.tap(PLUGIN_NAME, (resolveData) => {
 				const result = this.checkIgnore(resolveData);
 
 				if (
@@ -83,18 +83,21 @@ class IgnorePlugin {
 					resolveData.dependencies.length > 0 &&
 					resolveData.dependencies[0] instanceof EntryDependency
 				) {
-					resolveData.ignoredModule = new RawModule(
+					const module = new RawModule(
 						"",
 						"ignored-entry-module",
 						"(ignored-entry-module)"
 					);
+					module.factoryMeta = { sideEffectFree: true };
+
+					resolveData.ignoredModule = module;
 				}
 
 				return result;
 			});
 		});
-		compiler.hooks.contextModuleFactory.tap("IgnorePlugin", cmf => {
-			cmf.hooks.beforeResolve.tap("IgnorePlugin", this.checkIgnore);
+		compiler.hooks.contextModuleFactory.tap(PLUGIN_NAME, (cmf) => {
+			cmf.hooks.beforeResolve.tap(PLUGIN_NAME, this.checkIgnore);
 		});
 	}
 }

package/lib/IgnoreWarningsPlugin.js

@@ -8,6 +8,8 @@
 /** @typedef {import("../declarations/WebpackOptions").IgnoreWarningsNormalized} IgnoreWarningsNormalized */
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "IgnoreWarningsPlugin";
+
 class IgnoreWarningsPlugin {
 	/**
 	 * @param {IgnoreWarningsNormalized} ignoreWarnings conditions to ignore warnings
@@ -22,11 +24,11 @@ class IgnoreWarningsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("IgnoreWarningsPlugin", compilation => {
-			compilation.hooks.processWarnings.tap("IgnoreWarningsPlugin", warnings =>
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+			compilation.hooks.processWarnings.tap(PLUGIN_NAME, (warnings) =>
 				warnings.filter(
-					warning =>
-						!this._ignoreWarnings.some(ignore => ignore(warning, compilation))
+					(warning) =>
+						!this._ignoreWarnings.some((ignore) => ignore(warning, compilation))
 				)
 			);
 		});

package/lib/InitFragment.js

@@ -13,18 +13,32 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {string} InitFragmentKey */
+
+/**
+ * @template GenerateContext
+ * @typedef {object} MaybeMergeableInitFragment
+ * @property {InitFragmentKey=} key
+ * @property {number} stage
+ * @property {number} position
+ * @property {(context: GenerateContext) => string | Source | undefined} getContent
+ * @property {(context: GenerateContext) => string | Source | undefined} getEndContent
+ * @property {(fragments: MaybeMergeableInitFragment<GenerateContext>) => MaybeMergeableInitFragment<GenerateContext>=} merge
+ * @property {(fragments: MaybeMergeableInitFragment<GenerateContext>[]) => MaybeMergeableInitFragment<GenerateContext>[]=} mergeAll
+ */
+
 /**
  * @template T
- * @param {InitFragment<T>} fragment the init fragment
+ * @param {T} fragment the init fragment
  * @param {number} index index
- * @returns {[InitFragment<T>, number]} tuple with both
+ * @returns {[T, number]} tuple with both
  */
 const extractFragmentIndex = (fragment, index) => [fragment, index];
 
 /**
  * @template T
- * @param {[InitFragment<T>, number]} a first pair
- * @param {[InitFragment<T>, number]} b second pair
+ * @param {[MaybeMergeableInitFragment<T>, number]} a first pair
+ * @param {[MaybeMergeableInitFragment<T>, number]} b second pair
  * @returns {number} sort value
  */
 const sortFragmentWithIndex = ([a, i], [b, j]) => {
@@ -37,13 +51,14 @@ const sortFragmentWithIndex = ([a, i], [b, j]) => {
 
 /**
  * @template GenerateContext
+ * @implements {MaybeMergeableInitFragment<GenerateContext>}
  */
 class InitFragment {
 	/**
 	 * @param {string | Source | undefined} content the source code that will be included as initialization code
 	 * @param {number} stage category of initialization code (contribute to order)
 	 * @param {number} position position in the category (contribute to order)
-	 * @param {string=} key unique key to avoid emitting the same initialization code twice
+	 * @param {InitFragmentKey=} key unique key to avoid emitting the same initialization code twice
 	 * @param {string | Source=} endContent the source code that will be included at the end of the module
 	 */
 	constructor(content, stage, position, key, endContent) {
@@ -64,7 +79,7 @@ class InitFragment {
 
 	/**
 	 * @param {GenerateContext} context context
-	 * @returns {string|Source=} the source code that will be included at the end of the module
+	 * @returns {string | Source | undefined} the source code that will be included at the end of the module
 	 */
 	getEndContent(context) {
 		return this.endContent;
@@ -72,9 +87,8 @@ class InitFragment {
 
 	/**
 	 * @template Context
-	 * @template T
 	 * @param {Source} source sources
-	 * @param {InitFragment<T>[]} initFragments init fragments
+	 * @param {MaybeMergeableInitFragment<Context>[]} initFragments init fragments
 	 * @param {Context} context context
 	 * @returns {Source} source
 	 */
@@ -87,14 +101,10 @@ class InitFragment {
 				.sort(sortFragmentWithIndex);
 
 			// Deduplicate fragments. If a fragment has no key, it is always included.
+			/** @type {Map<InitFragmentKey | symbol, MaybeMergeableInitFragment<Context> | MaybeMergeableInitFragment<Context>[]>} */
 			const keyedFragments = new Map();
 			for (const [fragment] of sortedFragments) {
-				if (
-					typeof (
-						/** @type {InitFragment<T> & { mergeAll?: (fragments: InitFragment<Context>[]) => InitFragment<Context>[] }} */
-						(fragment).mergeAll
-					) === "function"
-				) {
+				if (typeof fragment.mergeAll === "function") {
 					if (!fragment.key) {
 						throw new Error(
 							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
@@ -110,9 +120,12 @@ class InitFragment {
 					}
 					continue;
 				} else if (typeof fragment.merge === "function") {
-					const oldValue = keyedFragments.get(fragment.key);
+					const key = /** @type {InitFragmentKey} */ (fragment.key);
+					const oldValue =
+						/** @type {MaybeMergeableInitFragment<Context>} */
+						(keyedFragments.get(key));
 					if (oldValue !== undefined) {
-						keyedFragments.set(fragment.key, fragment.merge(oldValue));
+						keyedFragments.set(key, fragment.merge(oldValue));
 						continue;
 					}
 				}
@@ -123,10 +136,19 @@ class InitFragment {
 			const endContents = [];
 			for (let fragment of keyedFragments.values()) {
 				if (Array.isArray(fragment)) {
-					fragment = fragment[0].mergeAll(fragment);
+					fragment =
+						/** @type {[MaybeMergeableInitFragment<Context> & { mergeAll: (fragments: MaybeMergeableInitFragment<Context>[]) => MaybeMergeableInitFragment<Context>[] }, ...MaybeMergeableInitFragment<Context>[]]} */
+						(fragment)[0].mergeAll(fragment);
 				}
-				concatSource.add(fragment.getContent(context));
-				const endContent = fragment.getEndContent(context);
+				const content =
+					/** @type {MaybeMergeableInitFragment<Context>} */
+					(fragment).getContent(context);
+				if (content) {
+					concatSource.add(content);
+				}
+				const endContent =
+					/** @type {MaybeMergeableInitFragment<Context>} */
+					(fragment).getEndContent(context);
 				if (endContent) {
 					endContents.push(endContent);
 				}
@@ -170,10 +192,6 @@ class InitFragment {
 
 makeSerializable(InitFragment, "webpack/lib/InitFragment");
 
-InitFragment.prototype.merge =
-	/** @type {TODO} */
-	(undefined);
-
 InitFragment.STAGE_CONSTANTS = 10;
 InitFragment.STAGE_ASYNC_BOUNDARY = 20;
 InitFragment.STAGE_HARMONY_EXPORTS = 30;

package/lib/InvalidDependenciesModuleWarning.js

@@ -8,7 +8,6 @@
 const WebpackError = require("./WebpackError");
 const makeSerializable = require("./util/makeSerializable");
 
-/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module")} Module */
 
 class InvalidDependenciesModuleWarning extends WebpackError {
@@ -17,8 +16,8 @@ class InvalidDependenciesModuleWarning extends WebpackError {
 	 * @param {Iterable<string>} deps invalid dependencies
 	 */
 	constructor(module, deps) {
-		const orderedDeps = deps ? Array.from(deps).sort() : [];
-		const depsList = orderedDeps.map(dep => ` * ${JSON.stringify(dep)}`);
+		const orderedDeps = deps ? [...deps].sort() : [];
+		const depsList = orderedDeps.map((dep) => ` * ${JSON.stringify(dep)}`);
 		super(`Invalid dependencies have been reported by plugins or loaders for this module. All reported dependencies need to be absolute paths.
 Invalid dependencies may lead to broken watching and caching.
 As best effort we try to convert all invalid values to absolute paths and converting globs into context dependencies, but this is deprecated behavior.

package/lib/JavascriptMetaInfoPlugin.js

@@ -32,13 +32,12 @@ class JavascriptMetaInfoPlugin {
 				 * @param {JavascriptParser} parser the parser
 				 * @returns {void}
 				 */
-				const handler = parser => {
+				const handler = (parser) => {
 					parser.hooks.call.for("eval").tap(PLUGIN_NAME, () => {
 						const buildInfo =
 							/** @type {BuildInfo} */
 							(parser.state.module.buildInfo);
 						buildInfo.moduleConcatenationBailout = "eval()";
-						buildInfo.usingEval = true;
 						const currentSymbol = InnerGraph.getTopLevelSymbol(parser.state);
 						if (currentSymbol) {
 							InnerGraph.addUsage(parser.state, null, currentSymbol);
@@ -55,8 +54,7 @@ class JavascriptMetaInfoPlugin {
 							topLevelDeclarations = buildInfo.topLevelDeclarations = new Set();
 						}
 						for (const name of parser.scope.definitions.asSet()) {
-							const freeInfo = parser.getFreeInfoFromVariable(name);
-							if (freeInfo === undefined) {
+							if (parser.isVariableDefined(name)) {
 								topLevelDeclarations.add(name);
 							}
 						}

package/lib/LibManifestPlugin.js

@@ -15,12 +15,13 @@ const { dirname, mkdirp } = require("./util/fs");
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Compiler").IntermediateFileSystem} IntermediateFileSystem */
 /** @typedef {import("./Module").BuildMeta} BuildMeta */
+/** @typedef {import("./ExportsInfo").ExportInfoName} ExportInfoName */
 
 /**
  * @typedef {object} ManifestModuleData
- * @property {string | number} id
- * @property {BuildMeta} buildMeta
- * @property {boolean | string[] | undefined} exports
+ * @property {ModuleId} id
+ * @property {BuildMeta=} buildMeta
+ * @property {ExportInfoName[]=} exports
  */
 
 /**
@@ -33,6 +34,8 @@ const { dirname, mkdirp } = require("./util/fs");
  * @property {string=} type Type of the dll bundle (external type, use value of 'output.libraryTarget').
  */
 
+const PLUGIN_NAME = "LibManifestPlugin";
+
 class LibManifestPlugin {
 	/**
 	 * @param {LibManifestPluginOptions} options the options
@@ -48,16 +51,13 @@ class LibManifestPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.emit.tapAsync(
-			{
-				name: "LibManifestPlugin",
-				stage: 110
-			},
+			{ name: PLUGIN_NAME, stage: 110 },
 			(compilation, callback) => {
 				const moduleGraph = compilation.moduleGraph;
 				// store used paths to detect issue and output an error. #18200
 				const usedPaths = new Set();
 				asyncLib.each(
-					Array.from(compilation.chunks),
+					[...compilation.chunks],
 					(chunk, callback) => {
 						if (!chunk.canBeInitial()) {
 							callback();
@@ -87,15 +87,13 @@ class LibManifestPlugin {
 								this.options.entryOnly &&
 								!someInIterable(
 									moduleGraph.getIncomingConnections(module),
-									c => c.dependency instanceof EntryDependency
+									(c) => c.dependency instanceof EntryDependency
 								)
 							) {
 								continue;
 							}
 							const ident = module.libIdent({
-								context:
-									this.options.context ||
-									/** @type {string} */ (compiler.options.context),
+								context: this.options.context || compiler.context,
 								associatedObjectForCache: compiler.root
 							});
 							if (ident) {
@@ -129,7 +127,7 @@ class LibManifestPlugin {
 						mkdirp(
 							intermediateFileSystem,
 							dirname(intermediateFileSystem, targetPath),
-							err => {
+							(err) => {
 								if (err) return callback(err);
 								intermediateFileSystem.writeFile(targetPath, buffer, callback);
 							}
@@ -141,4 +139,5 @@ class LibManifestPlugin {
 		);
 	}
 }
+
 module.exports = LibManifestPlugin;

package/lib/LoaderOptionsPlugin.js

@@ -13,8 +13,13 @@ const createSchemaValidation = require("./util/create-schema-validation");
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./ModuleFilenameHelpers").MatchObject} MatchObject  */
 
+/**
+ * @template T
+ * @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ */
+
 const validate = createSchemaValidation(
-	require("../schemas/plugins/LoaderOptionsPlugin.check.js"),
+	require("../schemas/plugins/LoaderOptionsPlugin.check"),
 	() => require("../schemas/plugins/LoaderOptionsPlugin.json"),
 	{
 		name: "Loader Options Plugin",
@@ -22,6 +27,8 @@ const validate = createSchemaValidation(
 	}
 );
 
+const PLUGIN_NAME = "LoaderOptionsPlugin";
+
 class LoaderOptionsPlugin {
 	/**
 	 * @param {LoaderOptionsPluginOptions & MatchObject} options options object
@@ -31,16 +38,7 @@ class LoaderOptionsPlugin {
 		// If no options are set then generate empty options object
 		if (typeof options !== "object") options = {};
 		if (!options.test) {
-			// This is mocking a RegExp object which always returns true
-			// TODO: Figure out how to do `as unknown as RegExp` for this line
-			// in JSDoc equivalent
-			/** @type {any} */
-			const defaultTrueMockRegExp = {
-				test: () => true
-			};
-
-			/** @type {RegExp} */
-			options.test = defaultTrueMockRegExp;
+			options.test = () => true;
 		}
 		this.options = options;
 	}
@@ -52,9 +50,9 @@ class LoaderOptionsPlugin {
 	 */
 	apply(compiler) {
 		const options = this.options;
-		compiler.hooks.compilation.tap("LoaderOptionsPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderOptionsPlugin",
+				PLUGIN_NAME,
 				(context, module) => {
 					const resource = module.resource;
 					if (!resource) return;
@@ -70,7 +68,7 @@ class LoaderOptionsPlugin {
 								continue;
 							}
 
-							/** @type {any} */
+							/** @type {LoaderContext<EXPECTED_ANY> & Record<string, EXPECTED_ANY>} */
 							(context)[key] = options[key];
 						}
 					}

package/lib/LoaderTargetPlugin.js

@@ -9,6 +9,8 @@ const NormalModule = require("./NormalModule");
 
 /** @typedef {import("./Compiler")} Compiler */
 
+const PLUGIN_NAME = "LoaderTargetPlugin";
+
 class LoaderTargetPlugin {
 	/**
 	 * @param {string} target the target
@@ -23,10 +25,10 @@ class LoaderTargetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap("LoaderTargetPlugin", compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			NormalModule.getCompilationHooks(compilation).loader.tap(
-				"LoaderTargetPlugin",
-				loaderContext => {
+				PLUGIN_NAME,
+				(loaderContext) => {
 					loaderContext.target = this.target;
 				}
 			);

package/lib/MainTemplate.js

@@ -5,13 +5,12 @@
 
 "use strict";
 
-const { SyncWaterfallHook } = require("tapable");
 const util = require("util");
+const { SyncWaterfallHook } = require("tapable");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const memoize = require("./util/memoize");
 
 /** @typedef {import("tapable").Tap} Tap */
-/** @typedef {import("webpack-sources").ConcatSource} ConcatSource */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").Output} OutputOptions */
 /** @typedef {import("./ModuleTemplate")} ModuleTemplate */
@@ -19,19 +18,13 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compilation").InterpolatedPathAndAssetInfo} InterpolatedPathAndAssetInfo */
-/** @typedef {import("./Module")} Module} */
-/** @typedef {import("./util/Hash")} Hash} */
-/** @typedef {import("./DependencyTemplates")} DependencyTemplates} */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderContext} RenderContext} */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderBootstrapContext} RenderBootstrapContext} */
-/** @typedef {import("./javascript/JavascriptModulesPlugin").ChunkHashContext} ChunkHashContext} */
-/** @typedef {import("./RuntimeTemplate")} RuntimeTemplate} */
-/** @typedef {import("./ModuleGraph")} ModuleGraph} */
-/** @typedef {import("./ChunkGraph")} ChunkGraph} */
-/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions} */
-/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry} */
-/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath} */
-/** @typedef {import("./TemplatedPathPlugin").PathData} PathData} */
+/** @typedef {import("./util/Hash")} Hash */
+/** @typedef {import("./DependencyTemplates")} DependencyTemplates */
+/** @typedef {import("./javascript/JavascriptModulesPlugin").RenderBootstrapContext} RenderBootstrapContext */
+/** @typedef {import("./Template").RenderManifestOptions} RenderManifestOptions */
+/** @typedef {import("./Template").RenderManifestEntry} RenderManifestEntry */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
+/** @typedef {import("./TemplatedPathPlugin").PathData} PathData */
 /**
  * @template T
  * @typedef {import("tapable").IfSet<T>} IfSet
@@ -62,7 +55,7 @@ class MainTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(RenderManifestEntry[], RenderManifestOptions): RenderManifestEntry[]} fn fn
+					 * @param {(renderManifestEntries: RenderManifestEntry[], renderManifestOptions: RenderManifestOptions) => RenderManifestEntry[]} fn fn
 					 */
 					(options, fn) => {
 						compilation.hooks.renderManifest.tap(
@@ -96,7 +89,7 @@ class MainTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(string, RenderBootstrapContext): string} fn fn
+					 * @param {(value: string, renderBootstrapContext: RenderBootstrapContext) => string} fn fn
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -133,7 +126,7 @@ class MainTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Source, Chunk, string | undefined, ModuleTemplate, DependencyTemplates): Source} fn fn
+					 * @param {(source: Source, chunk: Chunk, hash: string | undefined, moduleTemplate: ModuleTemplate, dependencyTemplates: DependencyTemplates) => Source} fn fn
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -165,7 +158,7 @@ class MainTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Source, Chunk, string | undefined): Source} fn fn
+					 * @param {(source: Source, chunk: Chunk, hash: string | undefined) => Source} fn fn
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -191,7 +184,7 @@ class MainTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(string, object, AssetInfo | undefined): string} fn fn
+					 * @param {(value: string, path: PathData, assetInfo: AssetInfo | undefined) => string} fn fn
 					 */
 					(options, fn) => {
 						compilation.hooks.assetPath.tap(options, fn);
@@ -215,7 +208,7 @@ class MainTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Hash): void} fn fn
+					 * @param {(hash: Hash) => void} fn fn
 					 */
 					(options, fn) => {
 						compilation.hooks.fullHash.tap(options, fn);
@@ -229,7 +222,7 @@ class MainTemplate {
 					/**
 					 * @template AdditionalOptions
 					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
-					 * @param {function(Hash, Chunk): void} fn fn
+					 * @param {(hash: Hash, chunk: Chunk) => void} fn fn
 					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
@@ -323,12 +316,8 @@ class MainTemplate {
 			/**
 			 * @param {PathData} options context data
 			 * @returns {string} interpolated path
-			 */ options =>
-				compilation.getAssetPath(
-					/** @type {string} */
-					(compilation.outputOptions.publicPath),
-					options
-				),
+			 */ (options) =>
+				compilation.getAssetPath(compilation.outputOptions.publicPath, options),
 			"MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)",
 			"DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH"
 		);
@@ -371,7 +360,7 @@ Object.defineProperty(MainTemplate.prototype, "outputOptions", {
 		 * @this {MainTemplate}
 		 * @returns {OutputOptions} output options
 		 */
-		function () {
+		function outputOptions() {
 			return this._outputOptions;
 		},
 		"MainTemplate.outputOptions is deprecated (use Compilation.outputOptions instead)",