webpack 5.59.0 → 5.94.0

package/lib/IgnoreErrorModuleFactory.js

@@ -26,13 +26,13 @@ class IgnoreErrorModuleFactory 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) {
-		this.normalModuleFactory.create(data, (err, result) => {
-			return callback(null, result);
-		});
+		this.normalModuleFactory.create(data, (err, result) =>
+			callback(null, result)
+		);
 	}
 }
 

package/lib/IgnorePlugin.js

@@ -28,14 +28,15 @@ class IgnorePlugin {
 		validate(options);
 		this.options = options;
 
-		/** @private @type {Function} */
+		/**
+		 * @private
+		 * @type {Function}
+		 */
 		this.checkIgnore = this.checkIgnore.bind(this);
 	}
 
 	/**
-	 * Note that if "contextRegExp" is given, both the "resourceRegExp"
-	 * and "contextRegExp" have to match.
-	 *
+	 * 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
 	 */

package/lib/IgnoreWarningsPlugin.js

@@ -15,6 +15,7 @@ class IgnoreWarningsPlugin {
 	constructor(ignoreWarnings) {
 		this._ignoreWarnings = ignoreWarnings;
 	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -22,15 +23,11 @@ class IgnoreWarningsPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("IgnoreWarningsPlugin", compilation => {
-			compilation.hooks.processWarnings.tap(
-				"IgnoreWarningsPlugin",
-				warnings => {
-					return warnings.filter(warning => {
-						return !this._ignoreWarnings.some(ignore =>
-							ignore(warning, compilation)
-						);
-					});
-				}
+			compilation.hooks.processWarnings.tap("IgnoreWarningsPlugin", warnings =>
+				warnings.filter(
+					warning =>
+						!this._ignoreWarnings.some(ignore => ignore(warning, compilation))
+				)
 			);
 		});
 	}

package/lib/InitFragment.js

@@ -10,17 +10,21 @@ const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Generator").GenerateContext} GenerateContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
 /**
- * @param {InitFragment} fragment the init fragment
+ * @template T
+ * @param {InitFragment<T>} fragment the init fragment
  * @param {number} index index
- * @returns {[InitFragment, number]} tuple with both
+ * @returns {[InitFragment<T>, number]} tuple with both
  */
 const extractFragmentIndex = (fragment, index) => [fragment, index];
 
 /**
- * @param {[InitFragment, number]} a first pair
- * @param {[InitFragment, number]} b second pair
+ * @template T
+ * @param {[InitFragment<T>, number]} a first pair
+ * @param {[InitFragment<T>, number]} b second pair
  * @returns {number} sort value
  */
 const sortFragmentWithIndex = ([a, i], [b, j]) => {
@@ -32,15 +36,15 @@ const sortFragmentWithIndex = ([a, i], [b, j]) => {
 };
 
 /**
- * @template Context
+ * @template GenerateContext
  */
 class InitFragment {
 	/**
-	 * @param {string|Source} content the source code that will be included as initialization code
+	 * @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 {string|Source=} endContent the source code that will be included at the end of the module
+	 * @param {string | Source=} endContent the source code that will be included at the end of the module
 	 */
 	constructor(content, stage, position, key, endContent) {
 		this.content = content;
@@ -51,21 +55,29 @@ class InitFragment {
 	}
 
 	/**
-	 * @param {Context} context context
-	 * @returns {string|Source} the source code that will be included as initialization code
+	 * @param {GenerateContext} context context
+	 * @returns {string | Source | undefined} the source code that will be included as initialization code
 	 */
 	getContent(context) {
 		return this.content;
 	}
 
 	/**
-	 * @param {Context} context context
+	 * @param {GenerateContext} context context
 	 * @returns {string|Source=} the source code that will be included at the end of the module
 	 */
 	getEndContent(context) {
 		return this.endContent;
 	}
 
+	/**
+	 * @template Context
+	 * @template T
+	 * @param {Source} source sources
+	 * @param {InitFragment<T>[]} initFragments init fragments
+	 * @param {Context} context context
+	 * @returns {Source} source
+	 */
 	static addToSource(source, initFragments, context) {
 		if (initFragments.length > 0) {
 			// Sort fragments by position. If 2 fragments have the same position,
@@ -77,7 +89,12 @@ class InitFragment {
 			// Deduplicate fragments. If a fragment has no key, it is always included.
 			const keyedFragments = new Map();
 			for (const [fragment] of sortedFragments) {
-				if (typeof fragment.mergeAll === "function") {
+				if (
+					typeof (
+						/** @type {InitFragment<T> & { mergeAll?: (fragments: InitFragment<Context>[]) => InitFragment<Context>[] }} */
+						(fragment).mergeAll
+					) === "function"
+				) {
 					if (!fragment.key) {
 						throw new Error(
 							`InitFragment with mergeAll function must have a valid key: ${fragment.constructor.name}`
@@ -99,7 +116,7 @@ class InitFragment {
 						continue;
 					}
 				}
-				keyedFragments.set(fragment.key || Symbol(), fragment);
+				keyedFragments.set(fragment.key || Symbol("fragment key"), fragment);
 			}
 
 			const concatSource = new ConcatSource();
@@ -120,11 +137,13 @@ class InitFragment {
 				concatSource.add(content);
 			}
 			return concatSource;
-		} else {
-			return source;
 		}
+		return source;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 
@@ -135,6 +154,9 @@ class InitFragment {
 		write(this.endContent);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 
@@ -148,7 +170,9 @@ class InitFragment {
 
 makeSerializable(InitFragment, "webpack/lib/InitFragment");
 
-InitFragment.prototype.merge = undefined;
+InitFragment.prototype.merge =
+	/** @type {TODO} */
+	(undefined);
 
 InitFragment.STAGE_CONSTANTS = 10;
 InitFragment.STAGE_ASYNC_BOUNDARY = 20;

package/lib/JavascriptMetaInfoPlugin.js

@@ -5,11 +5,19 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("./ModuleTypeConstants");
 const InnerGraph = require("./optimize/InnerGraph");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
 
+const PLUGIN_NAME = "JavascriptMetaInfoPlugin";
+
 class JavascriptMetaInfoPlugin {
 	/**
 	 * Apply the plugin
@@ -18,16 +26,19 @@ class JavascriptMetaInfoPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"JavascriptMetaInfoPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @returns {void}
 				 */
 				const handler = parser => {
-					parser.hooks.call.for("eval").tap("JavascriptMetaInfoPlugin", () => {
-						parser.state.module.buildInfo.moduleConcatenationBailout = "eval()";
-						parser.state.module.buildInfo.usingEval = true;
+					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);
@@ -35,12 +46,13 @@ class JavascriptMetaInfoPlugin {
 							InnerGraph.bailout(parser.state);
 						}
 					});
-					parser.hooks.finish.tap("JavascriptMetaInfoPlugin", () => {
-						let topLevelDeclarations =
-							parser.state.module.buildInfo.topLevelDeclarations;
+					parser.hooks.finish.tap(PLUGIN_NAME, () => {
+						const buildInfo =
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo);
+						let topLevelDeclarations = buildInfo.topLevelDeclarations;
 						if (topLevelDeclarations === undefined) {
-							topLevelDeclarations =
-								parser.state.module.buildInfo.topLevelDeclarations = new Set();
+							topLevelDeclarations = buildInfo.topLevelDeclarations = new Set();
 						}
 						for (const name of parser.scope.definitions.asSet()) {
 							const freeInfo = parser.getFreeInfoFromVariable(name);
@@ -52,14 +64,14 @@ class JavascriptMetaInfoPlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("JavascriptMetaInfoPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("JavascriptMetaInfoPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("JavascriptMetaInfoPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/LibManifestPlugin.js

@@ -11,16 +11,32 @@ const { someInIterable } = require("./util/IterableHelpers");
 const { compareModulesById } = require("./util/comparators");
 const { dirname, mkdirp } = require("./util/fs");
 
+/** @typedef {import("./ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Compiler").IntermediateFileSystem} IntermediateFileSystem */
+/** @typedef {import("./Module").BuildMeta} BuildMeta */
 
 /**
- * @typedef {Object} ManifestModuleData
+ * @typedef {object} ManifestModuleData
  * @property {string | number} id
- * @property {Object} buildMeta
- * @property {boolean | string[]} exports
+ * @property {BuildMeta} buildMeta
+ * @property {boolean | string[] | undefined} exports
+ */
+
+/**
+ * @typedef {object} LibManifestPluginOptions
+ * @property {string=} context Context of requests in the manifest file (defaults to the webpack context).
+ * @property {boolean=} entryOnly If true, only entry points will be exposed (default: true).
+ * @property {boolean=} format If true, manifest json file (output) will be formatted.
+ * @property {string=} name Name of the exposed dll function (external name, use value of 'output.library').
+ * @property {string} path Absolute path to the manifest json file (output).
+ * @property {string=} type Type of the dll bundle (external type, use value of 'output.libraryTarget').
  */
 
 class LibManifestPlugin {
+	/**
+	 * @param {LibManifestPluginOptions} options the options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -32,10 +48,15 @@ class LibManifestPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.emit.tapAsync(
-			"LibManifestPlugin",
+			{
+				name: "LibManifestPlugin",
+				stage: 110
+			},
 			(compilation, callback) => {
 				const moduleGraph = compilation.moduleGraph;
-				asyncLib.forEach(
+				// store used paths to detect issue and output an error. #18200
+				const usedPaths = new Set();
+				asyncLib.each(
 					Array.from(compilation.chunks),
 					(chunk, callback) => {
 						if (!chunk.canBeInitial()) {
@@ -46,10 +67,16 @@ class LibManifestPlugin {
 						const targetPath = compilation.getPath(this.options.path, {
 							chunk
 						});
+						if (usedPaths.has(targetPath)) {
+							callback(new Error("each chunk must have a unique path"));
+							return;
+						}
+						usedPaths.add(targetPath);
 						const name =
 							this.options.name &&
 							compilation.getPath(this.options.name, {
-								chunk
+								chunk,
+								contentHashType: "javascript"
 							});
 						const content = Object.create(null);
 						for (const module of chunkGraph.getOrderedChunkModulesIterable(
@@ -66,7 +93,9 @@ class LibManifestPlugin {
 								continue;
 							}
 							const ident = module.libIdent({
-								context: this.options.context || compiler.options.context,
+								context:
+									this.options.context ||
+									/** @type {string} */ (compiler.options.context),
 								associatedObjectForCache: compiler.root
 							});
 							if (ident) {
@@ -74,8 +103,8 @@ class LibManifestPlugin {
 								const providedExports = exportsInfo.getProvidedExports();
 								/** @type {ManifestModuleData} */
 								const data = {
-									id: chunkGraph.getModuleId(module),
-									buildMeta: module.buildMeta,
+									id: /** @type {ModuleId} */ (chunkGraph.getModuleId(module)),
+									buildMeta: /** @type {BuildMeta} */ (module.buildMeta),
 									exports: Array.isArray(providedExports)
 										? providedExports
 										: undefined
@@ -93,16 +122,16 @@ class LibManifestPlugin {
 							? JSON.stringify(manifest, null, 2)
 							: JSON.stringify(manifest);
 						const buffer = Buffer.from(manifestContent, "utf8");
+						const intermediateFileSystem =
+							/** @type {IntermediateFileSystem} */ (
+								compiler.intermediateFileSystem
+							);
 						mkdirp(
-							compiler.intermediateFileSystem,
-							dirname(compiler.intermediateFileSystem, targetPath),
+							intermediateFileSystem,
+							dirname(intermediateFileSystem, targetPath),
 							err => {
 								if (err) return callback(err);
-								compiler.intermediateFileSystem.writeFile(
-									targetPath,
-									buffer,
-									callback
-								);
+								intermediateFileSystem.writeFile(targetPath, buffer, callback);
 							}
 						);
 					},

package/lib/LoaderOptionsPlugin.js

@@ -11,6 +11,7 @@ const createSchemaValidation = require("./util/create-schema-validation");
 
 /** @typedef {import("../declarations/plugins/LoaderOptionsPlugin").LoaderOptionsPluginOptions} LoaderOptionsPluginOptions */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./ModuleFilenameHelpers").MatchObject} MatchObject  */
 
 const validate = createSchemaValidation(
 	require("../schemas/plugins/LoaderOptionsPlugin.check.js"),
@@ -20,17 +21,26 @@ const validate = createSchemaValidation(
 		baseDataPath: "options"
 	}
 );
+
 class LoaderOptionsPlugin {
 	/**
-	 * @param {LoaderOptionsPluginOptions} options options object
+	 * @param {LoaderOptionsPluginOptions & MatchObject} options options object
 	 */
 	constructor(options = {}) {
 		validate(options);
+		// If no options are set then generate empty options object
 		if (typeof options !== "object") options = {};
 		if (!options.test) {
-			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;
 		}
 		this.options = options;
 	}
@@ -52,7 +62,7 @@ class LoaderOptionsPlugin {
 					if (
 						ModuleFilenameHelpers.matchObject(
 							options,
-							i < 0 ? resource : resource.substr(0, i)
+							i < 0 ? resource : resource.slice(0, i)
 						)
 					) {
 						for (const key of Object.keys(options)) {

package/lib/MainTemplate.js

@@ -10,6 +10,7 @@ const util = require("util");
 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 */
@@ -17,15 +18,24 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Chunk")} Chunk */
 /** @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} */
+/**
+ * @template T
+ * @typedef {import("tapable").IfSet<T>} IfSet
+ */
 
 const getJavascriptModulesPlugin = memoize(() =>
 	require("./javascript/JavascriptModulesPlugin")
@@ -40,7 +50,6 @@ const getLoadScriptRuntimeModule = memoize(() =>
 // TODO webpack 6 remove this class
 class MainTemplate {
 	/**
-	 *
 	 * @param {OutputOptions} outputOptions output options for the MainTemplate
 	 * @param {Compilation} compilation the compilation
 	 */
@@ -50,6 +59,11 @@ class MainTemplate {
 		this.hooks = Object.freeze({
 			renderManifest: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(RenderManifestEntry[], RenderManifestOptions): RenderManifestEntry[]} fn fn
+					 */
 					(options, fn) => {
 						compilation.hooks.renderManifest.tap(
 							options,
@@ -79,6 +93,11 @@ class MainTemplate {
 			},
 			require: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(string, RenderBootstrapContext): string} fn fn
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -111,6 +130,11 @@ class MainTemplate {
 			},
 			render: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Source, Chunk, string | undefined, ModuleTemplate, DependencyTemplates): Source} fn fn
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -138,6 +162,11 @@ class MainTemplate {
 			},
 			renderWithEntry: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Source, Chunk, string | undefined): Source} fn fn
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -159,6 +188,11 @@ class MainTemplate {
 			},
 			assetPath: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(string, object, AssetInfo | undefined): string} fn fn
+					 */
 					(options, fn) => {
 						compilation.hooks.assetPath.tap(options, fn);
 					},
@@ -166,15 +200,23 @@ class MainTemplate {
 					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
 				),
 				call: util.deprecate(
-					(filename, options) => {
-						return compilation.getAssetPath(filename, options);
-					},
+					/**
+					 * @param {TemplatePath} filename used to get asset path with hash
+					 * @param {PathData} options context data
+					 * @returns {string} interpolated path
+					 */
+					(filename, options) => compilation.getAssetPath(filename, options),
 					"MainTemplate.hooks.assetPath is deprecated (use Compilation.hooks.assetPath instead)",
 					"DEP_WEBPACK_MAIN_TEMPLATE_ASSET_PATH"
 				)
 			},
 			hash: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Hash): void} fn fn
+					 */
 					(options, fn) => {
 						compilation.hooks.fullHash.tap(options, fn);
 					},
@@ -184,6 +226,11 @@ class MainTemplate {
 			},
 			hashForChunk: {
 				tap: util.deprecate(
+					/**
+					 * @template AdditionalOptions
+					 * @param {string | Tap & IfSet<AdditionalOptions>} options options
+					 * @param {function(Hash, Chunk): void} fn fn
+					 */
 					(options, fn) => {
 						getJavascriptModulesPlugin()
 							.getCompilationHooks(compilation)
@@ -259,7 +306,8 @@ class MainTemplate {
 			 * @param {string} hash the hash
 			 * @param {number=} length length of the hash
 			 * @returns {string} generated code
-			 */ (hash, length) => {
+			 */
+			(hash, length) => {
 				if (length) {
 					return `${RuntimeGlobals.getFullHash} ? ${
 						RuntimeGlobals.getFullHash
@@ -273,31 +321,36 @@ class MainTemplate {
 
 		this.getPublicPath = util.deprecate(
 			/**
-			 *
-			 * @param {object} options get public path options
-			 * @returns {string} hook call
-			 */ options => {
-				return compilation.getAssetPath(
-					compilation.outputOptions.publicPath,
+			 * @param {PathData} options context data
+			 * @returns {string} interpolated path
+			 */ options =>
+				compilation.getAssetPath(
+					/** @type {string} */
+					(compilation.outputOptions.publicPath),
 					options
-				);
-			},
+				),
 			"MainTemplate.getPublicPath is deprecated (use Compilation.getAssetPath(compilation.outputOptions.publicPath, options) instead)",
 			"DEP_WEBPACK_MAIN_TEMPLATE_GET_PUBLIC_PATH"
 		);
 
 		this.getAssetPath = util.deprecate(
-			(path, options) => {
-				return compilation.getAssetPath(path, options);
-			},
+			/**
+			 * @param {TemplatePath} path used to get asset path with hash
+			 * @param {PathData} options context data
+			 * @returns {string} interpolated path
+			 */
+			(path, options) => compilation.getAssetPath(path, options),
 			"MainTemplate.getAssetPath is deprecated (use Compilation.getAssetPath instead)",
 			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH"
 		);
 
 		this.getAssetPathWithInfo = util.deprecate(
-			(path, options) => {
-				return compilation.getAssetPathWithInfo(path, options);
-			},
+			/**
+			 * @param {TemplatePath} path used to get asset path with hash
+			 * @param {PathData} options context data
+			 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
+			 */
+			(path, options) => compilation.getAssetPathWithInfo(path, options),
 			"MainTemplate.getAssetPathWithInfo is deprecated (use Compilation.getAssetPath instead)",
 			"DEP_WEBPACK_MAIN_TEMPLATE_GET_ASSET_PATH_WITH_INFO"
 		);
@@ -306,8 +359,8 @@ class MainTemplate {
 
 Object.defineProperty(MainTemplate.prototype, "requireFn", {
 	get: util.deprecate(
-		() => "__webpack_require__",
-		'MainTemplate.requireFn is deprecated (use "__webpack_require__")',
+		() => RuntimeGlobals.require,
+		`MainTemplate.requireFn is deprecated (use "${RuntimeGlobals.require}")`,
 		"DEP_WEBPACK_MAIN_TEMPLATE_REQUIRE_FN"
 	)
 });