webpack 5.76.1 → 5.88.2

package/lib/dependencies/ImportMetaContextPlugin.js

@@ -5,12 +5,20 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const ContextElementDependency = require("./ContextElementDependency");
 const ImportMetaContextDependency = require("./ImportMetaContextDependency");
 const ImportMetaContextDependencyParserPlugin = require("./ImportMetaContextDependencyParserPlugin");
 
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "ImportMetaContextPlugin";
 
 class ImportMetaContextPlugin {
 	/**
@@ -20,7 +28,7 @@ class ImportMetaContextPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"RequireContextPlugin",
+			PLUGIN_NAME,
 			(compilation, { contextModuleFactory, normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					ImportMetaContextDependency,
@@ -35,6 +43,11 @@ class ImportMetaContextPlugin {
 					normalModuleFactory
 				);
 
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
 				const handler = (parser, parserOptions) => {
 					if (
 						parserOptions.importMetaContext !== undefined &&
@@ -46,11 +59,11 @@ class ImportMetaContextPlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportMetaContextPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportMetaContextPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}

package/lib/dependencies/ImportMetaHotAcceptDependency.js

@@ -9,7 +9,13 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
 
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
 class ImportMetaHotAcceptDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
 	constructor(request, range) {
 		super(request);
 		this.range = range;

package/lib/dependencies/ImportMetaHotDeclineDependency.js

@@ -9,7 +9,13 @@ const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 const ModuleDependencyTemplateAsId = require("./ModuleDependencyTemplateAsId");
 
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+
 class ImportMetaHotDeclineDependency extends ModuleDependency {
+	/**
+	 * @param {string} request the request string
+	 * @param {Range} range location in source code
+	 */
 	constructor(request, range) {
 		super(request);
 

package/lib/dependencies/ImportMetaPlugin.js

@@ -7,6 +7,10 @@
 
 const { pathToFileURL } = require("url");
 const ModuleDependencyWarning = require("../ModuleDependencyWarning");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const Template = require("../Template");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const {
@@ -22,20 +26,24 @@ const ConstDependency = require("./ConstDependency");
 /** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 const getCriticalDependencyWarning = memoize(() =>
 	require("./CriticalDependencyWarning")
 );
 
+const PLUGIN_NAME = "ImportMetaPlugin";
+
 class ImportMetaPlugin {
 	/**
 	 * @param {Compiler} compiler compiler
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"ImportMetaPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				/**
 				 * @param {NormalModule} module module
@@ -56,12 +64,12 @@ class ImportMetaPlugin {
 
 						parser.hooks.expression
 							.for("import.meta")
-							.tap("ImportMetaPlugin", metaProperty => {
+							.tap(PLUGIN_NAME, metaProperty => {
 								const dep = new ConstDependency(
-									importMetaName,
-									metaProperty.range
+									/** @type {string} */ (importMetaName),
+									/** @type {Range} */ (metaProperty.range)
 								);
-								dep.loc = metaProperty.loc;
+								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 								parser.state.module.addPresentationalDependency(dep);
 								return true;
 							});
@@ -69,38 +77,88 @@ class ImportMetaPlugin {
 					}
 
 					/// import.meta direct ///
+					const webpackVersion = parseInt(
+						require("../../package.json").version,
+						10
+					);
+					const importMetaUrl = () =>
+						JSON.stringify(getUrl(parser.state.module));
+					const importMetaWebpackVersion = () => JSON.stringify(webpackVersion);
+					/**
+					 * @param {string[]} members members
+					 * @returns {string} error message
+					 */
+					const importMetaUnknownProperty = members =>
+						`${Template.toNormalComment(
+							"unsupported import.meta." + members.join(".")
+						)} undefined${propertyAccess(members, 1)}`;
 					parser.hooks.typeof
 						.for("import.meta")
 						.tap(
-							"ImportMetaPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("object"))
 						);
 					parser.hooks.expression
 						.for("import.meta")
-						.tap("ImportMetaPlugin", metaProperty => {
-							const CriticalDependencyWarning = getCriticalDependencyWarning();
-							parser.state.module.addWarning(
-								new ModuleDependencyWarning(
-									parser.state.module,
-									new CriticalDependencyWarning(
-										"Accessing import.meta directly is unsupported (only property access is supported)"
-									),
-									metaProperty.loc
-								)
-							);
+						.tap(PLUGIN_NAME, metaProperty => {
+							const referencedPropertiesInDestructuring =
+								parser.destructuringAssignmentPropertiesFor(metaProperty);
+							if (!referencedPropertiesInDestructuring) {
+								const CriticalDependencyWarning =
+									getCriticalDependencyWarning();
+								parser.state.module.addWarning(
+									new ModuleDependencyWarning(
+										parser.state.module,
+										new CriticalDependencyWarning(
+											"Accessing import.meta directly is unsupported (only property access or destructuring is supported)"
+										),
+										/** @type {DependencyLocation} */ (metaProperty.loc)
+									)
+								);
+								const dep = new ConstDependency(
+									`${
+										parser.isAsiPosition(
+											/** @type {Range} */ (metaProperty.range)[0]
+										)
+											? ";"
+											: ""
+									}({})`,
+									/** @type {Range} */ (metaProperty.range)
+								);
+								dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							}
+
+							let str = "";
+							for (const prop of referencedPropertiesInDestructuring) {
+								switch (prop) {
+									case "url":
+										str += `url: ${importMetaUrl()},`;
+										break;
+									case "webpack":
+										str += `webpack: ${importMetaWebpackVersion()},`;
+										break;
+									default:
+										str += `[${JSON.stringify(
+											prop
+										)}]: ${importMetaUnknownProperty([prop])},`;
+										break;
+								}
+							}
 							const dep = new ConstDependency(
-								`${parser.isAsiPosition(metaProperty.range[0]) ? ";" : ""}({})`,
-								metaProperty.range
+								`({${str}})`,
+								/** @type {Range} */ (metaProperty.range)
 							);
-							dep.loc = metaProperty.loc;
+							dep.loc = /** @type {DependencyLocation} */ (metaProperty.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 					parser.hooks.evaluateTypeof
 						.for("import.meta")
-						.tap("ImportMetaPlugin", evaluateToString("object"));
+						.tap(PLUGIN_NAME, evaluateToString("object"));
 					parser.hooks.evaluateIdentifier.for("import.meta").tap(
-						"ImportMetaPlugin",
+						PLUGIN_NAME,
 						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
 					);
 
@@ -108,72 +166,66 @@ class ImportMetaPlugin {
 					parser.hooks.typeof
 						.for("import.meta.url")
 						.tap(
-							"ImportMetaPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("string"))
 						);
 					parser.hooks.expression
 						.for("import.meta.url")
-						.tap("ImportMetaPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							const dep = new ConstDependency(
-								JSON.stringify(getUrl(parser.state.module)),
-								expr.range
+								importMetaUrl(),
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 					parser.hooks.evaluateTypeof
 						.for("import.meta.url")
-						.tap("ImportMetaPlugin", evaluateToString("string"));
+						.tap(PLUGIN_NAME, evaluateToString("string"));
 					parser.hooks.evaluateIdentifier
 						.for("import.meta.url")
-						.tap("ImportMetaPlugin", expr => {
+						.tap(PLUGIN_NAME, expr => {
 							return new BasicEvaluatedExpression()
 								.setString(getUrl(parser.state.module))
-								.setRange(expr.range);
+								.setRange(/** @type {Range} */ (expr.range));
 						});
 
 					/// import.meta.webpack ///
-					const webpackVersion = parseInt(
-						require("../../package.json").version,
-						10
-					);
 					parser.hooks.typeof
 						.for("import.meta.webpack")
 						.tap(
-							"ImportMetaPlugin",
+							PLUGIN_NAME,
 							toConstantDependency(parser, JSON.stringify("number"))
 						);
 					parser.hooks.expression
 						.for("import.meta.webpack")
 						.tap(
-							"ImportMetaPlugin",
-							toConstantDependency(parser, JSON.stringify(webpackVersion))
+							PLUGIN_NAME,
+							toConstantDependency(parser, importMetaWebpackVersion())
 						);
 					parser.hooks.evaluateTypeof
 						.for("import.meta.webpack")
-						.tap("ImportMetaPlugin", evaluateToString("number"));
+						.tap(PLUGIN_NAME, evaluateToString("number"));
 					parser.hooks.evaluateIdentifier
 						.for("import.meta.webpack")
-						.tap("ImportMetaPlugin", evaluateToNumber(webpackVersion));
+						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
 
 					/// Unknown properties ///
 					parser.hooks.unhandledExpressionMemberChain
 						.for("import.meta")
-						.tap("ImportMetaPlugin", (expr, members) => {
+						.tap(PLUGIN_NAME, (expr, members) => {
 							const dep = new ConstDependency(
-								`${Template.toNormalComment(
-									"unsupported import.meta." + members.join(".")
-								)} undefined${propertyAccess(members, 1)}`,
-								expr.range
+								importMetaUnknownProperty(members),
+								/** @type {Range} */ (expr.range)
 							);
-							dep.loc = expr.loc;
+							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 							parser.state.module.addPresentationalDependency(dep);
 							return true;
 						});
 					parser.hooks.evaluate
 						.for("MemberExpression")
-						.tap("ImportMetaPlugin", expression => {
+						.tap(PLUGIN_NAME, expression => {
 							const expr = /** @type {MemberExpression} */ (expression);
 							if (
 								expr.object.type === "MetaProperty" &&
@@ -184,17 +236,17 @@ class ImportMetaPlugin {
 							) {
 								return new BasicEvaluatedExpression()
 									.setUndefined()
-									.setRange(expr.range);
+									.setRange(/** @type {Range} */ (expr.range));
 							}
 						});
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportMetaPlugin", parserHandler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, parserHandler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportMetaPlugin", parserHandler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, parserHandler);
 			}
 		);
 	}

package/lib/dependencies/ImportParserPlugin.js

@@ -17,6 +17,10 @@ const ImportWeakDependency = require("./ImportWeakDependency");
 /** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../ContextModule").ContextMode} ContextMode */
+/** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
+/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
 
 class ImportParserPlugin {
 	/**
@@ -26,13 +30,23 @@ class ImportParserPlugin {
 		this.options = options;
 	}
 
+	/**
+	 * @param {JavascriptParser} parser the parser
+	 * @returns {void}
+	 */
 	apply(parser) {
+		/**
+		 * @template T
+		 * @param {Iterable<T>} enumerable enumerable
+		 * @returns {T[][]} array of array
+		 */
+		const exportsFromEnumerable = enumerable =>
+			Array.from(enumerable, e => [e]);
 		parser.hooks.importCall.tap("ImportParserPlugin", expr => {
 			const param = parser.evaluateExpression(expr.source);
 
 			let chunkName = null;
-			/** @type {ContextMode} */
-			let mode = this.options.dynamicImportMode;
+			let mode = /** @type {ContextMode} */ (this.options.dynamicImportMode);
 			let include = null;
 			let exclude = null;
 			/** @type {string[][] | null} */
@@ -40,7 +54,11 @@ class ImportParserPlugin {
 			/** @type {RawChunkGroupOptions} */
 			const groupOptions = {};
 
-			const { dynamicImportPreload, dynamicImportPrefetch } = this.options;
+			const {
+				dynamicImportPreload,
+				dynamicImportPrefetch,
+				dynamicImportFetchPriority
+			} = this.options;
 			if (dynamicImportPreload !== undefined && dynamicImportPreload !== false)
 				groupOptions.preloadOrder =
 					dynamicImportPreload === true ? 0 : dynamicImportPreload;
@@ -50,9 +68,14 @@ class ImportParserPlugin {
 			)
 				groupOptions.prefetchOrder =
 					dynamicImportPrefetch === true ? 0 : dynamicImportPrefetch;
+			if (
+				dynamicImportFetchPriority !== undefined &&
+				dynamicImportFetchPriority !== false
+			)
+				groupOptions.fetchPriority = dynamicImportFetchPriority;
 
 			const { options: importOptions, errors: commentErrors } =
-				parser.parseCommentOptions(expr.range);
+				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 
 			if (commentErrors) {
 				for (const e of commentErrors) {
@@ -72,7 +95,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -87,7 +110,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackChunkName\` expected a string, but received: ${importOptions.webpackChunkName}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -99,7 +122,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackMode\` expected a string, but received: ${importOptions.webpackMode}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -115,7 +138,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPrefetch\` expected true or a number, but received: ${importOptions.webpackPrefetch}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					}
@@ -129,7 +152,22 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackPreload\` expected true or a number, but received: ${importOptions.webpackPreload}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
+							)
+						);
+					}
+				}
+				if (importOptions.webpackFetchPriority !== undefined) {
+					if (
+						typeof importOptions.webpackFetchPriority === "string" &&
+						["high", "low", "auto"].includes(importOptions.webpackFetchPriority)
+					) {
+						groupOptions.fetchPriority = importOptions.webpackFetchPriority;
+					} else {
+						parser.state.module.addWarning(
+							new UnsupportedFeatureWarning(
+								`\`webpackFetchPriority\` expected true or "low", "high" or "auto", but received: ${importOptions.webpackFetchPriority}.`,
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					}
@@ -142,7 +180,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackInclude\` expected a regular expression, but received: ${importOptions.webpackInclude}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -157,7 +195,7 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExclude\` expected a regular expression, but received: ${importOptions.webpackExclude}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
@@ -169,7 +207,7 @@ class ImportParserPlugin {
 						!(
 							typeof importOptions.webpackExports === "string" ||
 							(Array.isArray(importOptions.webpackExports) &&
-								importOptions.webpackExports.every(
+								/** @type {string[]} */ (importOptions.webpackExports).every(
 									item => typeof item === "string"
 								))
 						)
@@ -177,14 +215,14 @@ class ImportParserPlugin {
 						parser.state.module.addWarning(
 							new UnsupportedFeatureWarning(
 								`\`webpackExports\` expected a string or an array of strings, but received: ${importOptions.webpackExports}.`,
-								expr.loc
+								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
 					} else {
 						if (typeof importOptions.webpackExports === "string") {
 							exports = [[importOptions.webpackExports]];
 						} else {
-							exports = Array.from(importOptions.webpackExports, e => [e]);
+							exports = exportsFromEnumerable(importOptions.webpackExports);
 						}
 					}
 				}
@@ -199,24 +237,38 @@ class ImportParserPlugin {
 				parser.state.module.addWarning(
 					new UnsupportedFeatureWarning(
 						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-						expr.loc
+						/** @type {DependencyLocation} */ (expr.loc)
 					)
 				);
 				mode = "lazy";
 			}
 
+			const referencedPropertiesInDestructuring =
+				parser.destructuringAssignmentPropertiesFor(expr);
+			if (referencedPropertiesInDestructuring) {
+				if (exports) {
+					parser.state.module.addWarning(
+						new UnsupportedFeatureWarning(
+							`\`webpackExports\` could not be used with destructuring assignment.`,
+							/** @type {DependencyLocation} */ (expr.loc)
+						)
+					);
+				}
+				exports = exportsFromEnumerable(referencedPropertiesInDestructuring);
+			}
+
 			if (param.isString()) {
 				if (mode === "eager") {
 					const dep = new ImportEagerDependency(
-						param.string,
-						expr.range,
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
 						exports
 					);
 					parser.state.current.addDependency(dep);
 				} else if (mode === "weak") {
 					const dep = new ImportWeakDependency(
-						param.string,
-						expr.range,
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
 						exports
 					);
 					parser.state.current.addDependency(dep);
@@ -226,11 +278,15 @@ class ImportParserPlugin {
 							...groupOptions,
 							name: chunkName
 						},
-						expr.loc,
+						/** @type {DependencyLocation} */ (expr.loc),
 						param.string
 					);
-					const dep = new ImportDependency(param.string, expr.range, exports);
-					dep.loc = expr.loc;
+					const dep = new ImportDependency(
+						/** @type {string} */ (param.string),
+						/** @type {Range} */ (expr.range),
+						exports
+					);
+					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
 				}
@@ -241,7 +297,7 @@ class ImportParserPlugin {
 				}
 				const dep = ContextDependencyHelpers.create(
 					ImportContextDependency,
-					expr.range,
+					/** @type {Range} */ (expr.range),
 					param,
 					expr,
 					this.options,
@@ -251,7 +307,9 @@ class ImportParserPlugin {
 						include,
 						exclude,
 						mode,
-						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
+						namespaceObject: /** @type {BuildMeta} */ (
+							parser.state.module.buildMeta
+						).strictHarmonyModule
 							? "strict"
 							: true,
 						typePrefix: "import()",
@@ -261,7 +319,7 @@ class ImportParserPlugin {
 					parser
 				);
 				if (!dep) return;
-				dep.loc = expr.loc;
+				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				dep.optional = !!parser.scope.inTry;
 				parser.state.current.addDependency(dep);
 				return true;

package/lib/dependencies/ImportPlugin.js

@@ -5,13 +5,22 @@
 
 "use strict";
 
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../ModuleTypeConstants");
 const ImportContextDependency = require("./ImportContextDependency");
 const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
 const ImportParserPlugin = require("./ImportParserPlugin");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../javascript/JavascriptParser")} Parser */
+
+const PLUGIN_NAME = "ImportPlugin";
 
 class ImportPlugin {
 	/**
@@ -21,7 +30,7 @@ class ImportPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"ImportPlugin",
+			PLUGIN_NAME,
 			(compilation, { contextModuleFactory, normalModuleFactory }) => {
 				compilation.dependencyFactories.set(
 					ImportDependency,
@@ -59,6 +68,11 @@ class ImportPlugin {
 					new ImportContextDependency.Template()
 				);
 
+				/**
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
+				 * @returns {void}
+				 */
 				const handler = (parser, parserOptions) => {
 					if (parserOptions.import !== undefined && !parserOptions.import)
 						return;
@@ -67,14 +81,14 @@ class ImportPlugin {
 				};
 
 				normalModuleFactory.hooks.parser
-					.for("javascript/auto")
-					.tap("ImportPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_AUTO)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/dynamic")
-					.tap("ImportPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_DYNAMIC)
+					.tap(PLUGIN_NAME, handler);
 				normalModuleFactory.hooks.parser
-					.for("javascript/esm")
-					.tap("ImportPlugin", handler);
+					.for(JAVASCRIPT_MODULE_TYPE_ESM)
+					.tap(PLUGIN_NAME, handler);
 			}
 		);
 	}