webpack 5.59.0 → 5.94.0

package/lib/APIPlugin.js

@@ -5,10 +5,17 @@
 
 "use strict";
 
+const InitFragment = require("./InitFragment");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const WebpackError = require("./WebpackError");
 const ConstDependency = require("./dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression");
+const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 const {
 	toConstantDependency,
 	evaluateToString
@@ -17,103 +24,127 @@ const ChunkNameRuntimeModule = require("./runtime/ChunkNameRuntimeModule");
 const GetFullHashRuntimeModule = require("./runtime/GetFullHashRuntimeModule");
 
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
-/* eslint-disable camelcase */
-const REPLACEMENTS = {
-	__webpack_require__: {
-		expr: RuntimeGlobals.require,
-		req: [RuntimeGlobals.require],
-		type: "function",
-		assign: false
-	},
-	__webpack_public_path__: {
-		expr: RuntimeGlobals.publicPath,
-		req: [RuntimeGlobals.publicPath],
-		type: "string",
-		assign: true
-	},
-	__webpack_base_uri__: {
-		expr: RuntimeGlobals.baseURI,
-		req: [RuntimeGlobals.baseURI],
-		type: "string",
-		assign: true
-	},
-	__webpack_modules__: {
-		expr: RuntimeGlobals.moduleFactories,
-		req: [RuntimeGlobals.moduleFactories],
-		type: "object",
-		assign: false
-	},
-	__webpack_chunk_load__: {
-		expr: RuntimeGlobals.ensureChunk,
-		req: [RuntimeGlobals.ensureChunk],
-		type: "function",
-		assign: true
-	},
-	__non_webpack_require__: {
-		expr: "require",
-		req: null,
-		type: undefined, // type is not known, depends on environment
-		assign: true
-	},
-	__webpack_nonce__: {
-		expr: RuntimeGlobals.scriptNonce,
-		req: [RuntimeGlobals.scriptNonce],
-		type: "string",
-		assign: true
-	},
-	__webpack_hash__: {
-		expr: `${RuntimeGlobals.getFullHash}()`,
-		req: [RuntimeGlobals.getFullHash],
-		type: "string",
-		assign: false
-	},
-	__webpack_chunkname__: {
-		expr: RuntimeGlobals.chunkName,
-		req: [RuntimeGlobals.chunkName],
-		type: "string",
-		assign: false
-	},
-	__webpack_get_script_filename__: {
-		expr: RuntimeGlobals.getChunkScriptFilename,
-		req: [RuntimeGlobals.getChunkScriptFilename],
-		type: "function",
-		assign: true
-	},
-	__webpack_runtime_id__: {
-		expr: RuntimeGlobals.runtimeId,
-		req: [RuntimeGlobals.runtimeId],
-		assign: false
-	},
-	"require.onError": {
-		expr: RuntimeGlobals.uncaughtErrorHandler,
-		req: [RuntimeGlobals.uncaughtErrorHandler],
-		type: undefined, // type is not known, could be function or undefined
-		assign: true // is never a pattern
-	},
-	__system_context__: {
-		expr: RuntimeGlobals.systemContext,
-		req: [RuntimeGlobals.systemContext],
-		type: "object",
-		assign: false
-	},
-	__webpack_share_scopes__: {
-		expr: RuntimeGlobals.shareScopeMap,
-		req: [RuntimeGlobals.shareScopeMap],
-		type: "object",
-		assign: false
-	},
-	__webpack_init_sharing__: {
-		expr: RuntimeGlobals.initializeSharing,
-		req: [RuntimeGlobals.initializeSharing],
-		type: "function",
-		assign: true
-	}
-};
-/* eslint-enable camelcase */
+/**
+ * @param {boolean | undefined} module true if ES module
+ * @param {string} importMetaName `import.meta` name
+ * @returns {Record<string, {expr: string, req: string[] | null, type?: string, assign: boolean}>} replacements
+ */
+function getReplacements(module, importMetaName) {
+	return {
+		__webpack_require__: {
+			expr: RuntimeGlobals.require,
+			req: [RuntimeGlobals.require],
+			type: "function",
+			assign: false
+		},
+		__webpack_public_path__: {
+			expr: RuntimeGlobals.publicPath,
+			req: [RuntimeGlobals.publicPath],
+			type: "string",
+			assign: true
+		},
+		__webpack_base_uri__: {
+			expr: RuntimeGlobals.baseURI,
+			req: [RuntimeGlobals.baseURI],
+			type: "string",
+			assign: true
+		},
+		__webpack_modules__: {
+			expr: RuntimeGlobals.moduleFactories,
+			req: [RuntimeGlobals.moduleFactories],
+			type: "object",
+			assign: false
+		},
+		__webpack_chunk_load__: {
+			expr: RuntimeGlobals.ensureChunk,
+			req: [RuntimeGlobals.ensureChunk],
+			type: "function",
+			assign: true
+		},
+		__non_webpack_require__: {
+			expr: module
+				? `__WEBPACK_EXTERNAL_createRequire(${importMetaName}.url)`
+				: "require",
+			req: null,
+			type: undefined, // type is not known, depends on environment
+			assign: true
+		},
+		__webpack_nonce__: {
+			expr: RuntimeGlobals.scriptNonce,
+			req: [RuntimeGlobals.scriptNonce],
+			type: "string",
+			assign: true
+		},
+		__webpack_hash__: {
+			expr: `${RuntimeGlobals.getFullHash}()`,
+			req: [RuntimeGlobals.getFullHash],
+			type: "string",
+			assign: false
+		},
+		__webpack_chunkname__: {
+			expr: RuntimeGlobals.chunkName,
+			req: [RuntimeGlobals.chunkName],
+			type: "string",
+			assign: false
+		},
+		__webpack_get_script_filename__: {
+			expr: RuntimeGlobals.getChunkScriptFilename,
+			req: [RuntimeGlobals.getChunkScriptFilename],
+			type: "function",
+			assign: true
+		},
+		__webpack_runtime_id__: {
+			expr: RuntimeGlobals.runtimeId,
+			req: [RuntimeGlobals.runtimeId],
+			assign: false
+		},
+		"require.onError": {
+			expr: RuntimeGlobals.uncaughtErrorHandler,
+			req: [RuntimeGlobals.uncaughtErrorHandler],
+			type: undefined, // type is not known, could be function or undefined
+			assign: true // is never a pattern
+		},
+		__system_context__: {
+			expr: RuntimeGlobals.systemContext,
+			req: [RuntimeGlobals.systemContext],
+			type: "object",
+			assign: false
+		},
+		__webpack_share_scopes__: {
+			expr: RuntimeGlobals.shareScopeMap,
+			req: [RuntimeGlobals.shareScopeMap],
+			type: "object",
+			assign: false
+		},
+		__webpack_init_sharing__: {
+			expr: RuntimeGlobals.initializeSharing,
+			req: [RuntimeGlobals.initializeSharing],
+			type: "function",
+			assign: true
+		}
+	};
+}
+
+const PLUGIN_NAME = "APIPlugin";
+
+/**
+ * @typedef {object} APIPluginOptions
+ * @property {boolean} [module] the output filename
+ */
 
 class APIPlugin {
+	/**
+	 * @param {APIPluginOptions} [options] options
+	 */
+	constructor(options = {}) {
+		this.options = options;
+	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -121,8 +152,16 @@ class APIPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"APIPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				const importMetaName = /** @type {string} */ (
+					compilation.outputOptions.importMetaName
+				);
+				const REPLACEMENTS = getReplacements(
+					this.options.module,
+					importMetaName
+				);
+
 				compilation.dependencyTemplates.set(
 					ConstDependency,
 					new ConstDependency.Template()
@@ -130,88 +169,153 @@ class APIPlugin {
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.chunkName)
-					.tap("APIPlugin", chunk => {
+					.tap(PLUGIN_NAME, chunk => {
 						compilation.addRuntimeModule(
 							chunk,
-							new ChunkNameRuntimeModule(chunk.name)
+							new ChunkNameRuntimeModule(/** @type {string} */ (chunk.name))
 						);
 						return true;
 					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.getFullHash)
-					.tap("APIPlugin", (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, set) => {
 						compilation.addRuntimeModule(chunk, new GetFullHashRuntimeModule());
 						return true;
 					});
 
+				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
+
+				hooks.renderModuleContent.tap(
+					PLUGIN_NAME,
+					(source, module, renderContext) => {
+						if (/** @type {BuildInfo} */ (module.buildInfo).needCreateRequire) {
+							const needPrefix =
+								renderContext.runtimeTemplate.supportNodePrefixForCoreModules();
+							const chunkInitFragments = [
+								new InitFragment(
+									`import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "${
+										needPrefix ? "node:" : ""
+									}module";\n`,
+									InitFragment.STAGE_HARMONY_IMPORTS,
+									0,
+									"external module node-commonjs"
+								)
+							];
+
+							renderContext.chunkInitFragments.push(...chunkInitFragments);
+						}
+
+						return source;
+					}
+				);
+
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 */
 				const handler = parser => {
-					Object.keys(REPLACEMENTS).forEach(key => {
+					for (const key of Object.keys(REPLACEMENTS)) {
 						const info = REPLACEMENTS[key];
-						parser.hooks.expression
-							.for(key)
-							.tap(
-								"APIPlugin",
-								toConstantDependency(parser, info.expr, info.req)
-							);
+						parser.hooks.expression.for(key).tap(PLUGIN_NAME, expression => {
+							const dep = toConstantDependency(parser, info.expr, info.req);
+
+							if (key === "__non_webpack_require__" && this.options.module) {
+								/** @type {BuildInfo} */
+								(parser.state.module.buildInfo).needCreateRequire = true;
+							}
+
+							return dep(expression);
+						});
 						if (info.assign === false) {
-							parser.hooks.assign.for(key).tap("APIPlugin", expr => {
+							parser.hooks.assign.for(key).tap(PLUGIN_NAME, expr => {
 								const err = new WebpackError(`${key} must not be assigned`);
-								err.loc = expr.loc;
+								err.loc = /** @type {DependencyLocation} */ (expr.loc);
 								throw err;
 							});
 						}
 						if (info.type) {
 							parser.hooks.evaluateTypeof
 								.for(key)
-								.tap("APIPlugin", evaluateToString(info.type));
+								.tap(PLUGIN_NAME, evaluateToString(info.type));
 						}
-					});
+					}
 
 					parser.hooks.expression
 						.for("__webpack_layer__")
-						.tap("APIPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							const dep = new ConstDependency(
 								JSON.stringify(parser.state.module.layer),
-								expr.range
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 					parser.hooks.evaluateIdentifier
 						.for("__webpack_layer__")
-						.tap("APIPlugin", expr =>
+						.tap(PLUGIN_NAME, expr =>
 							(parser.state.module.layer === null
 								? new BasicEvaluatedExpression().setNull()
 								: new BasicEvaluatedExpression().setString(
 										parser.state.module.layer
-								  )
-							).setRange(expr.range)
+									)
+							).setRange(/** @type {Range} */ (expr.range))
 						);
 					parser.hooks.evaluateTypeof
 						.for("__webpack_layer__")
-						.tap("APIPlugin", expr =>
+						.tap(PLUGIN_NAME, expr =>
 							new BasicEvaluatedExpression()
 								.setString(
 									parser.state.module.layer === null ? "object" : "string"
 								)
-								.setRange(expr.range)
+								.setRange(/** @type {Range} */ (expr.range))
 						);
+
+					parser.hooks.expression
+						.for("__webpack_module__.id")
+						.tap(PLUGIN_NAME, expr => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleConcatenationBailout =
+								"__webpack_module__.id";
+							const dep = new ConstDependency(
+								`${parser.state.module.moduleArgument}.id`,
+								/** @type {Range} */ (expr.range),
+								[RuntimeGlobals.moduleId]
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+
+					parser.hooks.expression
+						.for("__webpack_module__")
+						.tap(PLUGIN_NAME, expr => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleConcatenationBailout =
+								"__webpack_module__";
+							const dep = new ConstDependency(
+								parser.state.module.moduleArgument,
+								/** @type {Range} */ (expr.range),
+								[RuntimeGlobals.module]
+							);
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+							parser.state.module.addPresentationalDependency(dep);
+							return true;
+						});
+					parser.hooks.evaluateTypeof
+						.for("__webpack_module__")
+						.tap(PLUGIN_NAME, evaluateToString("object"));
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("APIPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("APIPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("APIPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/AbstractMethodError.js

@@ -13,18 +13,22 @@ const CURRENT_METHOD_REGEXP = /at ([a-zA-Z0-9_.]*)/;
  * @returns {string} message
  */
 function createMessage(method) {
-	return `Abstract method${method ? " " + method : ""}. Must be overridden.`;
+	return `Abstract method${method ? ` ${method}` : ""}. Must be overridden.`;
 }
 
 /**
  * @constructor
  */
 function Message() {
-	/** @type {string} */
+	/** @type {string | undefined} */
 	this.stack = undefined;
 	Error.captureStackTrace(this);
-	/** @type {RegExpMatchArray} */
-	const match = this.stack.split("\n")[3].match(CURRENT_METHOD_REGEXP);
+	/** @type {RegExpMatchArray | null} */
+	const match =
+		/** @type {string} */
+		(/** @type {unknown} */ (this.stack))
+			.split("\n")[3]
+			.match(CURRENT_METHOD_REGEXP);
 
 	this.message = match && match[1] ? createMessage(match[1]) : createMessage();
 }
@@ -32,12 +36,13 @@ function Message() {
 /**
  * Error for abstract method
  * @example
+ * ```js
  * class FooClass {
  *     abstractMethod() {
  *         throw new AbstractMethodError(); // error message: Abstract method FooClass.abstractMethod. Must be overridden.
  *     }
  * }
- *
+ * ```
  */
 class AbstractMethodError extends WebpackError {
 	constructor() {

package/lib/AsyncDependenciesBlock.js

@@ -15,13 +15,15 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 
 class AsyncDependenciesBlock extends DependenciesBlock {
 	/**
-	 * @param {ChunkGroupOptions & { entryOptions?: EntryOptions }} groupOptions options for the group
-	 * @param {DependencyLocation=} loc the line of code
-	 * @param {string=} request the request
+	 * @param {(ChunkGroupOptions & { entryOptions?: EntryOptions }) | null} groupOptions options for the group
+	 * @param {(DependencyLocation | null)=} loc the line of code
+	 * @param {(string | null)=} request the request
 	 */
 	constructor(groupOptions, loc, request) {
 		super();
@@ -37,14 +39,14 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 	}
 
 	/**
-	 * @returns {string} The name of the chunk
+	 * @returns {string | undefined} The name of the chunk
 	 */
 	get chunkName() {
 		return this.groupOptions.name;
 	}
 
 	/**
-	 * @param {string} value The new chunk name
+	 * @param {string | undefined} value The new chunk name
 	 * @returns {void}
 	 */
 	set chunkName(value) {
@@ -71,6 +73,9 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this.groupOptions);
@@ -79,6 +84,9 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize(context) {
 		const { read } = context;
 		this.groupOptions = read();

package/lib/AutomaticPrefetchPlugin.js

@@ -27,6 +27,7 @@ class AutomaticPrefetchPlugin {
 				);
 			}
 		);
+		/** @type {{context: string | null, request: string}[] | null} */
 		let lastModules = null;
 		compiler.hooks.afterCompile.tap("AutomaticPrefetchPlugin", compilation => {
 			lastModules = [];
@@ -44,7 +45,7 @@ class AutomaticPrefetchPlugin {
 			"AutomaticPrefetchPlugin",
 			(compilation, callback) => {
 				if (!lastModules) return callback();
-				asyncLib.forEach(
+				asyncLib.each(
 					lastModules,
 					(m, callback) => {
 						compilation.addModuleChain(

package/lib/BannerPlugin.js

@@ -11,9 +11,12 @@ const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const Template = require("./Template");
 const createSchemaValidation = require("./util/create-schema-validation");
 
+/** @typedef {import("../declarations/plugins/BannerPlugin").BannerFunction} BannerFunction */
 /** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
 /** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginOptions} BannerPluginOptions */
+/** @typedef {import("./Compilation").PathData} PathData */
 /** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./TemplatedPathPlugin").TemplatePath} TemplatePath */
 
 const validate = createSchemaValidation(
 	require("../schemas/plugins/BannerPlugin.check.js"),
@@ -24,6 +27,10 @@ const validate = createSchemaValidation(
 	}
 );
 
+/**
+ * @param {string} str string to wrap
+ * @returns {string} wrapped string
+ */
 const wrapComment = str => {
 	if (!str.includes("\n")) {
 		return Template.toComment(str);
@@ -33,7 +40,7 @@ const wrapComment = str => {
 		.split("\n")
 		.join("\n * ")
 		.replace(/\s+\n/g, "\n")
-		.trimRight()}\n */`;
+		.trimEnd()}\n */`;
 };
 
 class BannerPlugin {
@@ -54,13 +61,15 @@ class BannerPlugin {
 		const bannerOption = options.banner;
 		if (typeof bannerOption === "function") {
 			const getBanner = bannerOption;
+			/** @type {BannerFunction} */
 			this.banner = this.options.raw
 				? getBanner
-				: data => wrapComment(getBanner(data));
+				: /** @type {BannerFunction} */ data => wrapComment(getBanner(data));
 		} else {
 			const banner = this.options.raw
 				? bannerOption
 				: wrapComment(bannerOption);
+			/** @type {BannerFunction} */
 			this.banner = () => banner;
 		}
 	}
@@ -77,12 +86,15 @@ class BannerPlugin {
 			undefined,
 			options
 		);
+		const cache = new WeakMap();
+		const stage =
+			this.options.stage || Compilation.PROCESS_ASSETS_STAGE_ADDITIONS;
 
 		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
 			compilation.hooks.processAssets.tap(
 				{
 					name: "BannerPlugin",
-					stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+					stage
 				},
 				() => {
 					for (const chunk of compilation.chunks) {
@@ -95,17 +107,26 @@ class BannerPlugin {
 								continue;
 							}
 
-							const data = {
-								chunk,
-								filename: file
-							};
+							/** @type {PathData} */
+							const data = { chunk, filename: file };
 
-							const comment = compilation.getPath(banner, data);
-
-							compilation.updateAsset(
-								file,
-								old => new ConcatSource(comment, "\n", old)
+							const comment = compilation.getPath(
+								/** @type {TemplatePath} */
+								(banner),
+								data
 							);
+
+							compilation.updateAsset(file, old => {
+								const cached = cache.get(old);
+								if (!cached || cached.comment !== comment) {
+									const source = options.footer
+										? new ConcatSource(old, "\n", comment)
+										: new ConcatSource(comment, "\n", old);
+									cache.set(old, { source, comment });
+									return source;
+								}
+								return cached.source;
+							});
 						}
 					}
 				}