webpack 5.77.0 → 5.78.0

package/lib/dependencies/SystemPlugin.js

@@ -5,6 +5,10 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const WebpackError = require("../WebpackError");
 const {
@@ -18,6 +22,8 @@ const SystemRuntimeModule = require("./SystemRuntimeModule");
 
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "SystemPlugin";
+
 class SystemPlugin {
 	/**
 	 * Apply the plugin
@@ -26,17 +32,17 @@ class SystemPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"SystemPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.hooks.runtimeRequirementInModule
 					.for(RuntimeGlobals.system)
-					.tap("SystemPlugin", (module, set) => {
+					.tap(PLUGIN_NAME, (module, set) => {
 						set.add(RuntimeGlobals.requireScope);
 					});
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.system)
-					.tap("SystemPlugin", (chunk, set) => {
+					.tap(PLUGIN_NAME, (chunk, set) => {
 						compilation.addRuntimeModule(chunk, new SystemRuntimeModule());
 					});
 
@@ -48,11 +54,11 @@ class SystemPlugin {
 					const setNotSupported = name => {
 						parser.hooks.evaluateTypeof
 							.for(name)
-							.tap("SystemPlugin", evaluateToString("undefined"));
+							.tap(PLUGIN_NAME, evaluateToString("undefined"));
 						parser.hooks.expression
 							.for(name)
 							.tap(
-								"SystemPlugin",
+								PLUGIN_NAME,
 								expressionIsUnsupported(
 									parser,
 									name + " is not supported by webpack."
@@ -63,27 +69,27 @@ class SystemPlugin {
 					parser.hooks.typeof
 						.for("System.import")
 						.tap(
-							"SystemPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("function"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("System.import")
-						.tap("SystemPlugin", evaluateToString("function"));
+						.tap(PLUGIN_NAME, evaluateToString("function"));
 					parser.hooks.typeof
 						.for("System")
 						.tap(
-							"SystemPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
 						);
 					parser.hooks.evaluateTypeof
 						.for("System")
-						.tap("SystemPlugin", evaluateToString("object"));
+						.tap(PLUGIN_NAME, evaluateToString("object"));
 
 					setNotSupported("System.set");
 					setNotSupported("System.get");
 					setNotSupported("System.register");
 
-					parser.hooks.expression.for("System").tap("SystemPlugin", expr => {
+					parser.hooks.expression.for("System").tap(PLUGIN_NAME, expr => {
 						const dep = new ConstDependency(RuntimeGlobals.system, expr.range, [
 							RuntimeGlobals.system
 						]);
@@ -92,7 +98,7 @@ class SystemPlugin {
 						return true;
 					});
 
-					parser.hooks.call.for("System.import").tap("SystemPlugin", expr => {
+					parser.hooks.call.for("System.import").tap(PLUGIN_NAME, expr => {
 						parser.state.module.addWarning(
 							new SystemImportDeprecationWarning(expr.loc)
 						);
@@ -107,11 +113,11 @@ class SystemPlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("SystemPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("SystemPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/dependencies/URLPlugin.js

@@ -6,6 +6,10 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const InnerGraph = require("../optimize/InnerGraph");
@@ -16,13 +20,15 @@ const URLDependency = require("./URLDependency");
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 
+const PLUGIN_NAME = "URLPlugin";
+
 class URLPlugin {
 	/**
 	 * @param {Compiler} compiler compiler
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"URLPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(URLDependency, normalModuleFactory);
 				compilation.dependencyTemplates.set(
@@ -76,10 +82,10 @@ class URLPlugin {
 						return request;
 					};
 
-					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
+					parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
 					parser.hooks.evaluateNewExpression
 						.for("URL")
-						.tap("URLPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							const request = getUrlRequest(expr);
 							if (!request) return;
 							const url = new URL(request, getUrl(parser.state.module));
@@ -88,7 +94,7 @@ class URLPlugin {
 								.setString(url.toString())
 								.setRange(expr.range);
 						});
-					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
+					parser.hooks.new.for("URL").tap(PLUGIN_NAME, _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
 
 						const request = getUrlRequest(expr);
@@ -107,7 +113,7 @@ class URLPlugin {
 						InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
 						return true;
 					});
-					parser.hooks.isPure.for("NewExpression").tap("URLPlugin", _expr => {
+					parser.hooks.isPure.for("NewExpression").tap(PLUGIN_NAME, _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
 						const { callee } = expr;
 						if (callee.type !== "Identifier") return;
@@ -121,12 +127,12 @@ class URLPlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("URLPlugin", parserCallback);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parserCallback);
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("URLPlugin", parserCallback);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parserCallback);
 			}
 		);
 	}

package/lib/dependencies/WorkerPlugin.js

@@ -8,6 +8,10 @@
 const { pathToFileURL } = require("url");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const { equals } = require("../util/ArrayHelpers");
@@ -47,6 +51,8 @@ const DEFAULT_SYNTAX = [
 /** @type {WeakMap<ParserState, number>} */
 const workerIndexMap = new WeakMap();
 
+const PLUGIN_NAME = "WorkerPlugin";
+
 class WorkerPlugin {
 	constructor(chunkLoading, wasmLoading, module, workerPublicPath) {
 		this._chunkLoading = chunkLoading;
@@ -71,7 +77,7 @@ class WorkerPlugin {
 			compiler.root
 		);
 		compiler.hooks.thisCompilation.tap(
-			"WorkerPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					WorkerDependency,
@@ -375,7 +381,7 @@ class WorkerPlugin {
 						if (item.endsWith("()")) {
 							parser.hooks.call
 								.for(item.slice(0, -2))
-								.tap("WorkerPlugin", handleNewWorker);
+								.tap(PLUGIN_NAME, handleNewWorker);
 						} else {
 							const match = /^(.+?)(\(\))?\s+from\s+(.+)$/.exec(item);
 							if (match) {
@@ -384,7 +390,7 @@ class WorkerPlugin {
 								const source = match[3];
 								(call ? parser.hooks.call : parser.hooks.new)
 									.for(harmonySpecifierTag)
-									.tap("WorkerPlugin", expr => {
+									.tap(PLUGIN_NAME, expr => {
 										const settings = /** @type {HarmonySettings} */ (
 											parser.currentTagData
 										);
@@ -398,7 +404,7 @@ class WorkerPlugin {
 										return handleNewWorker(expr);
 									});
 							} else {
-								parser.hooks.new.for(item).tap("WorkerPlugin", handleNewWorker);
+								parser.hooks.new.for(item).tap(PLUGIN_NAME, handleNewWorker);
 							}
 						}
 					};
@@ -409,11 +415,11 @@ class WorkerPlugin {
 					}
 				};
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("WorkerPlugin", parserPlugin);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parserPlugin);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("WorkerPlugin", parserPlugin);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parserPlugin);
 			}
 		);
 	}

package/lib/javascript/JavascriptModulesPlugin.js

@@ -18,6 +18,11 @@ const Compilation = require("../Compilation");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
@@ -133,6 +138,8 @@ const printGeneratedCodeForStack = (module, code) => {
 /** @type {WeakMap<Compilation, CompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
+const PLUGIN_NAME = "JavascriptModulesPlugin";
+
 class JavascriptModulesPlugin {
 	/**
 	 * @param {Compilation} compilation the compilation
@@ -196,154 +203,147 @@ class JavascriptModulesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"JavascriptModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const hooks = JavascriptModulesPlugin.getCompilationHooks(compilation);
 				normalModuleFactory.hooks.createParser
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", options => {
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, options => {
 						return new JavascriptParser("auto");
 					});
 				normalModuleFactory.hooks.createParser
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", options => {
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, options => {
 						return new JavascriptParser("script");
 					});
 				normalModuleFactory.hooks.createParser
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", options => {
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, options => {
 						return new JavascriptParser("module");
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/auto")
-					.tap("JavascriptModulesPlugin", () => {
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, () => {
 						return new JavascriptGenerator();
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/dynamic")
-					.tap("JavascriptModulesPlugin", () => {
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, () => {
 						return new JavascriptGenerator();
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("javascript/esm")
-					.tap("JavascriptModulesPlugin", () => {
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, () => {
 						return new JavascriptGenerator();
 					});
-				compilation.hooks.renderManifest.tap(
-					"JavascriptModulesPlugin",
-					(result, options) => {
-						const {
-							hash,
-							chunk,
-							chunkGraph,
-							moduleGraph,
-							runtimeTemplate,
-							dependencyTemplates,
-							outputOptions,
-							codeGenerationResults
-						} = options;
+				compilation.hooks.renderManifest.tap(PLUGIN_NAME, (result, options) => {
+					const {
+						hash,
+						chunk,
+						chunkGraph,
+						moduleGraph,
+						runtimeTemplate,
+						dependencyTemplates,
+						outputOptions,
+						codeGenerationResults
+					} = options;
 
-						const hotUpdateChunk =
-							chunk instanceof HotUpdateChunk ? chunk : null;
+					const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
 
-						let render;
-						const filenameTemplate =
-							JavascriptModulesPlugin.getChunkFilenameTemplate(
-								chunk,
-								outputOptions
+					let render;
+					const filenameTemplate =
+						JavascriptModulesPlugin.getChunkFilenameTemplate(
+							chunk,
+							outputOptions
+						);
+					if (hotUpdateChunk) {
+						render = () =>
+							this.renderChunk(
+								{
+									chunk,
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
+								},
+								hooks
 							);
-						if (hotUpdateChunk) {
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
-						} else if (chunk.hasRuntime()) {
-							render = () =>
-								this.renderMain(
-									{
-										hash,
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks,
-									compilation
-								);
-						} else {
-							if (!chunkHasJs(chunk, chunkGraph)) {
-								return result;
-							}
-
-							render = () =>
-								this.renderChunk(
-									{
-										chunk,
-										dependencyTemplates,
-										runtimeTemplate,
-										moduleGraph,
-										chunkGraph,
-										codeGenerationResults,
-										strictMode: runtimeTemplate.isModule()
-									},
-									hooks
-								);
+					} else if (chunk.hasRuntime()) {
+						render = () =>
+							this.renderMain(
+								{
+									hash,
+									chunk,
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
+								},
+								hooks,
+								compilation
+							);
+					} else {
+						if (!chunkHasJs(chunk, chunkGraph)) {
+							return result;
 						}
 
-						result.push({
-							render,
-							filenameTemplate,
-							pathOptions: {
-								hash,
-								runtime: chunk.runtime,
-								chunk,
-								contentHashType: "javascript"
-							},
-							info: {
-								javascriptModule: compilation.runtimeTemplate.isModule()
-							},
-							identifier: hotUpdateChunk
-								? `hotupdatechunk${chunk.id}`
-								: `chunk${chunk.id}`,
-							hash: chunk.contentHash.javascript
-						});
-
-						return result;
-					}
-				);
-				compilation.hooks.chunkHash.tap(
-					"JavascriptModulesPlugin",
-					(chunk, hash, context) => {
-						hooks.chunkHash.call(chunk, hash, context);
-						if (chunk.hasRuntime()) {
-							this.updateHashWithBootstrap(
-								hash,
+						render = () =>
+							this.renderChunk(
 								{
-									hash: "0000",
 									chunk,
-									codeGenerationResults: context.codeGenerationResults,
-									chunkGraph: context.chunkGraph,
-									moduleGraph: context.moduleGraph,
-									runtimeTemplate: context.runtimeTemplate
+									dependencyTemplates,
+									runtimeTemplate,
+									moduleGraph,
+									chunkGraph,
+									codeGenerationResults,
+									strictMode: runtimeTemplate.isModule()
 								},
 								hooks
 							);
-						}
 					}
-				);
-				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
+
+					result.push({
+						render,
+						filenameTemplate,
+						pathOptions: {
+							hash,
+							runtime: chunk.runtime,
+							chunk,
+							contentHashType: "javascript"
+						},
+						info: {
+							javascriptModule: compilation.runtimeTemplate.isModule()
+						},
+						identifier: hotUpdateChunk
+							? `hotupdatechunk${chunk.id}`
+							: `chunk${chunk.id}`,
+						hash: chunk.contentHash.javascript
+					});
+
+					return result;
+				});
+				compilation.hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, context) => {
+					hooks.chunkHash.call(chunk, hash, context);
+					if (chunk.hasRuntime()) {
+						this.updateHashWithBootstrap(
+							hash,
+							{
+								hash: "0000",
+								chunk,
+								codeGenerationResults: context.codeGenerationResults,
+								chunkGraph: context.chunkGraph,
+								moduleGraph: context.moduleGraph,
+								runtimeTemplate: context.runtimeTemplate
+							},
+							hooks
+						);
+					}
+				});
+				compilation.hooks.contentHash.tap(PLUGIN_NAME, chunk => {
 					const {
 						chunkGraph,
 						codeGenerationResults,
@@ -410,7 +410,7 @@ class JavascriptModulesPlugin {
 					);
 				});
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"JavascriptModulesPlugin",
+					PLUGIN_NAME,
 					(chunk, set, { chunkGraph }) => {
 						if (
 							!set.has(RuntimeGlobals.startupNoDefault) &&
@@ -421,58 +421,51 @@ class JavascriptModulesPlugin {
 						}
 					}
 				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source =
-							options.codeGenerationResult.sources.get("javascript");
-						if (source === undefined) return;
-						const { module, moduleObject } = options;
-						const code = source.source();
+				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
+					const source = options.codeGenerationResult.sources.get("javascript");
+					if (source === undefined) return;
+					const { module, moduleObject } = options;
+					const code = source.source();
 
-						const fn = vm.runInThisContext(
-							`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(
-								moduleObject.exports,
-								moduleObject,
-								moduleObject.exports,
-								context.__webpack_require__
-							);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
+					const fn = vm.runInThisContext(
+						`(function(${module.moduleArgument}, ${module.exportsArgument}, __webpack_require__) {\n${code}\n/**/})`,
+						{
+							filename: module.identifier(),
+							lineOffset: -1
 						}
+					);
+					try {
+						fn.call(
+							moduleObject.exports,
+							moduleObject,
+							moduleObject.exports,
+							context.__webpack_require__
+						);
+					} catch (e) {
+						e.stack += printGeneratedCodeForStack(options.module, code);
+						throw e;
 					}
-				);
-				compilation.hooks.executeModule.tap(
-					"JavascriptModulesPlugin",
-					(options, context) => {
-						const source = options.codeGenerationResult.sources.get("runtime");
-						if (source === undefined) return;
-						let code = source.source();
-						if (typeof code !== "string") code = code.toString();
+				});
+				compilation.hooks.executeModule.tap(PLUGIN_NAME, (options, context) => {
+					const source = options.codeGenerationResult.sources.get("runtime");
+					if (source === undefined) return;
+					let code = source.source();
+					if (typeof code !== "string") code = code.toString();
 
-						const fn = vm.runInThisContext(
-							`(function(__webpack_require__) {\n${code}\n/**/})`,
-							{
-								filename: options.module.identifier(),
-								lineOffset: -1
-							}
-						);
-						try {
-							fn.call(null, context.__webpack_require__);
-						} catch (e) {
-							e.stack += printGeneratedCodeForStack(options.module, code);
-							throw e;
+					const fn = vm.runInThisContext(
+						`(function(__webpack_require__) {\n${code}\n/**/})`,
+						{
+							filename: options.module.identifier(),
+							lineOffset: -1
 						}
+					);
+					try {
+						fn.call(null, context.__webpack_require__);
+					} catch (e) {
+						e.stack += printGeneratedCodeForStack(options.module, code);
+						throw e;
 					}
-				);
+				});
 			}
 		);
 	}