webpack 5.92.1 → 5.94.0

package/lib/dependencies/ImportMetaPlugin.js

@@ -49,9 +49,7 @@ class ImportMetaPlugin {
 				 * @param {NormalModule} module module
 				 * @returns {string} file url
 				 */
-				const getUrl = module => {
-					return pathToFileURL(module.resource).toString();
-				};
+				const getUrl = module => pathToFileURL(module.resource).toString();
 				/**
 				 * @param {Parser} parser parser parser
 				 * @param {JavascriptParserOptions} parserOptions parserOptions
@@ -76,8 +74,8 @@ class ImportMetaPlugin {
 						return;
 					}
 
-					/// import.meta direct ///
-					const webpackVersion = parseInt(
+					// import.meta direct
+					const webpackVersion = Number.parseInt(
 						require("../../package.json").version,
 						10
 					);
@@ -90,7 +88,7 @@ class ImportMetaPlugin {
 					 */
 					const importMetaUnknownProperty = members =>
 						`${Template.toNormalComment(
-							"unsupported import.meta." + members.join(".")
+							`unsupported import.meta.${members.join(".")}`
 						)} undefined${propertyAccess(members, 1)}`;
 					parser.hooks.typeof
 						.for("import.meta")
@@ -162,7 +160,7 @@ class ImportMetaPlugin {
 						evaluateToIdentifier("import.meta", "import.meta", () => [], true)
 					);
 
-					/// import.meta.url ///
+					// import.meta.url
 					parser.hooks.typeof
 						.for("import.meta.url")
 						.tap(
@@ -185,13 +183,13 @@ class ImportMetaPlugin {
 						.tap(PLUGIN_NAME, evaluateToString("string"));
 					parser.hooks.evaluateIdentifier
 						.for("import.meta.url")
-						.tap(PLUGIN_NAME, expr => {
-							return new BasicEvaluatedExpression()
+						.tap(PLUGIN_NAME, expr =>
+							new BasicEvaluatedExpression()
 								.setString(getUrl(parser.state.module))
-								.setRange(/** @type {Range} */ (expr.range));
-						});
+								.setRange(/** @type {Range} */ (expr.range))
+						);
 
-					/// import.meta.webpack ///
+					// import.meta.webpack
 					parser.hooks.typeof
 						.for("import.meta.webpack")
 						.tap(
@@ -211,7 +209,7 @@ class ImportMetaPlugin {
 						.for("import.meta.webpack")
 						.tap(PLUGIN_NAME, evaluateToNumber(webpackVersion));
 
-					/// Unknown properties ///
+					// Unknown properties
 					parser.hooks.unhandledExpressionMemberChain
 						.for("import.meta")
 						.tap(PLUGIN_NAME, (expr, members) => {

package/lib/dependencies/ImportParserPlugin.js

@@ -100,11 +100,9 @@ class ImportParserPlugin {
 								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
-					} else {
+					} else if (importOptions.webpackIgnore) {
 						// Do not instrument `import()` if `webpackIgnore` is `true`
-						if (importOptions.webpackIgnore) {
-							return false;
-						}
+						return false;
 					}
 				}
 				if (importOptions.webpackChunkName !== undefined) {
@@ -220,12 +218,10 @@ class ImportParserPlugin {
 								/** @type {DependencyLocation} */ (expr.loc)
 							)
 						);
+					} else if (typeof importOptions.webpackExports === "string") {
+						exports = [[importOptions.webpackExports]];
 					} else {
-						if (typeof importOptions.webpackExports === "string") {
-							exports = [[importOptions.webpackExports]];
-						} else {
-							exports = exportsFromEnumerable(importOptions.webpackExports);
-						}
+						exports = exportsFromEnumerable(importOptions.webpackExports);
 					}
 				}
 			}
@@ -251,7 +247,7 @@ class ImportParserPlugin {
 				if (exports) {
 					parser.state.module.addWarning(
 						new UnsupportedFeatureWarning(
-							`\`webpackExports\` could not be used with destructuring assignment.`,
+							"`webpackExports` could not be used with destructuring assignment.",
 							/** @type {DependencyLocation} */ (expr.loc)
 						)
 					);
@@ -296,45 +292,44 @@ class ImportParserPlugin {
 						attributes
 					);
 					dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-					dep.optional = !!parser.scope.inTry;
+					dep.optional = Boolean(parser.scope.inTry);
 					depBlock.addDependency(dep);
 					parser.state.current.addBlock(depBlock);
 				}
 				return true;
-			} else {
-				if (mode === "weak") {
-					mode = "async-weak";
-				}
-				const dep = ContextDependencyHelpers.create(
-					ImportContextDependency,
-					/** @type {Range} */ (expr.range),
-					param,
-					expr,
-					this.options,
-					{
-						chunkName,
-						groupOptions,
-						include,
-						exclude,
-						mode,
-						namespaceObject: /** @type {BuildMeta} */ (
-							parser.state.module.buildMeta
-						).strictHarmonyModule
-							? "strict"
-							: true,
-						typePrefix: "import()",
-						category: "esm",
-						referencedExports: exports,
-						attributes: getAttributes(expr)
-					},
-					parser
-				);
-				if (!dep) return;
-				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-				dep.optional = !!parser.scope.inTry;
-				parser.state.current.addDependency(dep);
-				return true;
 			}
+			if (mode === "weak") {
+				mode = "async-weak";
+			}
+			const dep = ContextDependencyHelpers.create(
+				ImportContextDependency,
+				/** @type {Range} */ (expr.range),
+				param,
+				expr,
+				this.options,
+				{
+					chunkName,
+					groupOptions,
+					include,
+					exclude,
+					mode,
+					namespaceObject: /** @type {BuildMeta} */ (
+						parser.state.module.buildMeta
+					).strictHarmonyModule
+						? "strict"
+						: true,
+					typePrefix: "import()",
+					category: "esm",
+					referencedExports: exports,
+					attributes: getAttributes(expr)
+				},
+				parser
+			);
+			if (!dep) return;
+			dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+			dep.optional = Boolean(parser.scope.inTry);
+			parser.state.current.addDependency(dep);
+			return true;
 		});
 	}
 }

package/lib/dependencies/JsonExportsDependency.js

@@ -14,33 +14,35 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../json/JsonData")} JsonData */
+/** @typedef {import("../json/JsonData").RawJsonData} RawJsonData */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
+/**
+ * @param {RawJsonData} data data
+ * @returns {TODO} value
+ */
 const getExportsFromData = data => {
 	if (data && typeof data === "object") {
 		if (Array.isArray(data)) {
 			return data.length < 100
-				? data.map((item, idx) => {
-						return {
-							name: `${idx}`,
-							canMangle: true,
-							exports: getExportsFromData(item)
-						};
-					})
+				? data.map((item, idx) => ({
+						name: `${idx}`,
+						canMangle: true,
+						exports: getExportsFromData(item)
+					}))
 				: undefined;
-		} else {
-			const exports = [];
-			for (const key of Object.keys(data)) {
-				exports.push({
-					name: key,
-					canMangle: true,
-					exports: getExportsFromData(data[key])
-				});
-			}
-			return exports;
 		}
+		const exports = [];
+		for (const key of Object.keys(data)) {
+			exports.push({
+				name: key,
+				canMangle: true,
+				exports: getExportsFromData(data[key])
+			});
+		}
+		return exports;
 	}
 	return undefined;
 };
@@ -65,7 +67,9 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	getExports(moduleGraph) {
 		return {
-			exports: getExportsFromData(this.data && this.data.get()),
+			exports: getExportsFromData(
+				this.data && /** @type {RawJsonData} */ (this.data.get())
+			),
 			dependencies: undefined
 		};
 	}

package/lib/dependencies/LoaderPlugin.js

@@ -10,17 +10,12 @@ const LazySet = require("../util/LazySet");
 const LoaderDependency = require("./LoaderDependency");
 const LoaderImportDependency = require("./LoaderImportDependency");
 
+/** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
 /** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
-
-/**
- * @callback LoadModuleCallback
- * @param {(Error | null)=} err error object
- * @param {string | Buffer=} source source code
- * @param {object=} map source map
- * @param {Module=} module loaded module if successful
- */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
 
 /**
  * @callback ImportModuleCallback
@@ -66,11 +61,6 @@ class LoaderPlugin {
 			NormalModule.getCompilationHooks(compilation).loader.tap(
 				"LoaderPlugin",
 				loaderContext => {
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {LoadModuleCallback} callback callback returning the loaded module or error
-					 * @returns {void}
-					 */
 					loaderContext.loadModule = (request, callback) => {
 						const dep = new LoaderDependency(request);
 						dep.loc = {
@@ -91,7 +81,9 @@ class LoaderPlugin {
 							{
 								factory,
 								dependencies: [dep],
-								originModule: loaderContext._module,
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
 								context: loaderContext.context,
 								recursive: false
 							},
@@ -117,7 +109,8 @@ class LoaderPlugin {
 										)
 									);
 								}
-								let source, map;
+								let map;
+								let source;
 								if (moduleSource.sourceAndMap) {
 									const sourceAndMap = moduleSource.sourceAndMap();
 									map = sourceAndMap.map;
@@ -149,15 +142,20 @@ class LoaderPlugin {
 								for (const d of buildDependencies) {
 									loaderContext.addBuildDependency(d);
 								}
-								return callback(null, source, map, referencedModule);
+								return callback(
+									null,
+									source,
+									/** @type {object | null} */ (map),
+									referencedModule
+								);
 							}
 						);
 					};
 
 					/**
 					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions=} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback} callback callback returning the exports
 					 * @returns {void}
 					 */
 					const importModule = (request, options, callback) => {
@@ -180,7 +178,9 @@ class LoaderPlugin {
 							{
 								factory,
 								dependencies: [dep],
-								originModule: loaderContext._module,
+								originModule:
+									/** @type {NormalModule} */
+									(loaderContext._module),
 								contextInfo: {
 									issuerLayer: options.layer
 								},
@@ -207,42 +207,53 @@ class LoaderPlugin {
 									},
 									(err, result) => {
 										if (err) return callback(err);
-										for (const d of result.fileDependencies) {
+										const {
+											fileDependencies,
+											contextDependencies,
+											missingDependencies,
+											buildDependencies,
+											cacheable,
+											assets,
+											exports
+										} = /** @type {ExecuteModuleResult} */ (result);
+										for (const d of fileDependencies) {
 											loaderContext.addDependency(d);
 										}
-										for (const d of result.contextDependencies) {
+										for (const d of contextDependencies) {
 											loaderContext.addContextDependency(d);
 										}
-										for (const d of result.missingDependencies) {
+										for (const d of missingDependencies) {
 											loaderContext.addMissingDependency(d);
 										}
-										for (const d of result.buildDependencies) {
+										for (const d of buildDependencies) {
 											loaderContext.addBuildDependency(d);
 										}
-										if (result.cacheable === false)
-											loaderContext.cacheable(false);
-										for (const [name, { source, info }] of result.assets) {
-											const { buildInfo } = loaderContext._module;
+										if (cacheable === false) loaderContext.cacheable(false);
+										for (const [name, { source, info }] of assets) {
+											const buildInfo =
+												/** @type {BuildInfo} */
+												(
+													/** @type {NormalModule} */ (loaderContext._module)
+														.buildInfo
+												);
 											if (!buildInfo.assets) {
 												buildInfo.assets = Object.create(null);
 												buildInfo.assetsInfo = new Map();
 											}
-											buildInfo.assets[name] = source;
-											buildInfo.assetsInfo.set(name, info);
+											/** @type {NonNullable<BuildInfo["assets"]>} */
+											(buildInfo.assets)[name] = source;
+											/** @type {NonNullable<BuildInfo["assetsInfo"]>} */
+											(buildInfo.assetsInfo).set(name, info);
 										}
-										callback(null, result.exports);
+										callback(null, exports);
 									}
 								);
 							}
 						);
 					};
 
-					/**
-					 * @param {string} request the request string to load the module from
-					 * @param {ImportModuleOptions} options options
-					 * @param {ImportModuleCallback=} callback callback returning the exports
-					 * @returns {Promise<any> | void} exports
-					 */
+					// eslint-disable-next-line no-warning-comments
+					// @ts-ignore Overloading doesn't work
 					loaderContext.importModule = (request, options, callback) => {
 						if (!callback) {
 							return new Promise((resolve, reject) => {

package/lib/dependencies/LocalModule.js

@@ -29,7 +29,7 @@ class LocalModule {
 	 * @returns {string} variable name
 	 */
 	variableName() {
-		return "__WEBPACK_LOCAL_MODULE_" + this.idx + "__";
+		return `__WEBPACK_LOCAL_MODULE_${this.idx}__`;
 	}
 
 	/**

package/lib/dependencies/LocalModulesHelpers.js

@@ -17,8 +17,8 @@ const LocalModule = require("./LocalModule");
 const lookup = (parent, mod) => {
 	if (mod.charAt(0) !== ".") return mod;
 
-	var path = parent.split("/");
-	var segments = mod.split("/");
+	const path = parent.split("/");
+	const segments = mod.split("/");
 	path.pop();
 
 	for (let i = 0; i < segments.length; i++) {
@@ -38,7 +38,7 @@ const lookup = (parent, mod) => {
  * @param {string} name name
  * @returns {LocalModule} local module
  */
-exports.addLocalModule = (state, name) => {
+module.exports.addLocalModule = (state, name) => {
 	if (!state.localModules) {
 		state.localModules = [];
 	}
@@ -53,7 +53,7 @@ exports.addLocalModule = (state, name) => {
  * @param {string} [namedModule] named module
  * @returns {LocalModule | null} local module or null
  */
-exports.getLocalModule = (state, name, namedModule) => {
+module.exports.getLocalModule = (state, name, namedModule) => {
 	if (!state.localModules) return null;
 	if (namedModule) {
 		// resolve dependency name relative to the defining named module

package/lib/dependencies/ModuleDecoratorDependency.js

@@ -50,7 +50,7 @@ class ModuleDecoratorDependency extends NullDependency {
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		return `self`;
+		return "self";
 	}
 
 	/**

package/lib/dependencies/ProvidedDependency.js

@@ -64,7 +64,7 @@ class ProvidedDependency extends ModuleDependency {
 	 * @returns {(string[] | ReferencedExport)[]} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		let ids = this.ids;
+		const ids = this.ids;
 		if (ids.length === 0) return Dependency.EXPORTS_OBJECT_REFERENCED;
 		return [ids];
 	}

package/lib/dependencies/PureExpressionDependency.js

@@ -77,12 +77,12 @@ class PureExpressionDependency extends NullDependency {
 			hash.update("null");
 		} else {
 			hash.update(
-				runtimeToString(runtimeCondition) +
-					"|" +
-					runtimeToString(context.runtime)
+				`${runtimeToString(runtimeCondition)}|${runtimeToString(
+					context.runtime
+				)}`
 			);
 		}
-		hash.update(this.range + "");
+		hash.update(String(this.range));
 	}
 
 	/**
@@ -136,11 +136,11 @@ PureExpressionDependency.Template = class PureExpressionDependencyTemplate exten
 		const dep = /** @type {PureExpressionDependency} */ (dependency);
 		const runtimeCondition = dep._getRuntimeCondition(moduleGraph, runtime);
 		if (runtimeCondition === true) {
-			return;
+			// Do nothing
 		} else if (runtimeCondition === false) {
 			source.insert(
 				dep.range[0],
-				`(/* unused pure expression or super */ null && (`
+				"(/* unused pure expression or super */ null && ("
 			);
 			source.insert(dep.range[1], "))");
 		} else {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -56,7 +56,7 @@ module.exports = class RequireContextDependencyParserPlugin {
 							/** @type {Range} */ (expr.range)
 						);
 						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-						dep.optional = !!parser.scope.inTry;
+						dep.optional = Boolean(parser.scope.inTry);
 						parser.state.current.addDependency(dep);
 						return true;
 					}

package/lib/dependencies/RuntimeRequirementsDependency.js

@@ -36,7 +36,7 @@ class RuntimeRequirementsDependency extends NullDependency {
 	 */
 	updateHash(hash, context) {
 		if (this._hashUpdate === undefined) {
-			this._hashUpdate = Array.from(this.runtimeRequirements).join() + "";
+			this._hashUpdate = `${Array.from(this.runtimeRequirements).join()}`;
 		}
 		hash.update(this._hashUpdate);
 	}

package/lib/dependencies/SystemPlugin.js

@@ -73,7 +73,7 @@ class SystemPlugin {
 								PLUGIN_NAME,
 								expressionIsUnsupported(
 									parser,
-									name + " is not supported by webpack."
+									`${name} is not supported by webpack.`
 								)
 							);
 					};

package/lib/dependencies/URLDependency.js

@@ -30,9 +30,9 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
-const getIgnoredRawDataUrlModule = memoize(() => {
-	return new RawDataUrlModule("data:,", `ignored-asset`, `(ignored asset)`);
-});
+const getIgnoredRawDataUrlModule = memoize(
+	() => new RawDataUrlModule("data:,", "ignored-asset", "(ignored asset)")
+);
 
 class URLDependency extends ModuleDependency {
 	/**

package/lib/dependencies/URLPlugin.js

@@ -6,13 +6,17 @@
 "use strict";
 
 const { pathToFileURL } = require("url");
+const CommentCompilationWarning = require("../CommentCompilationWarning");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_ESM
 } = require("../ModuleTypeConstants");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const InnerGraph = require("../optimize/InnerGraph");
+const ConstDependency = require("./ConstDependency");
 const URLDependency = require("./URLDependency");
 
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
@@ -44,8 +48,21 @@ class URLPlugin {
 				 * @param {NormalModule} module module
 				 * @returns {URL} file url
 				 */
-				const getUrl = module => {
-					return pathToFileURL(module.resource);
+				const getUrl = module => pathToFileURL(module.resource);
+
+				const isMetaUrl = (parser, arg) => {
+					const chain = parser.extractMemberExpressionChain(arg);
+
+					if (
+						chain.members.length !== 1 ||
+						chain.object.type !== "MetaProperty" ||
+						chain.object.meta.name !== "import" ||
+						chain.object.property.name !== "meta" ||
+						chain.members[0] !== "url"
+					)
+						return false;
+
+					return true;
 				};
 
 				/**
@@ -72,16 +89,7 @@ class URLPlugin {
 						)
 							return;
 
-						const chain = parser.extractMemberExpressionChain(arg2);
-
-						if (
-							chain.members.length !== 1 ||
-							chain.object.type !== "MetaProperty" ||
-							chain.object.meta.name !== "import" ||
-							chain.object.property.name !== "meta" ||
-							chain.members[0] !== "url"
-						)
-							return;
+						if (!isMetaUrl(parser, arg2)) return;
 
 						return parser.evaluateExpression(arg1).asString();
 					};
@@ -100,6 +108,52 @@ class URLPlugin {
 						});
 					parser.hooks.new.for("URL").tap(PLUGIN_NAME, _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
+						const { options: importOptions, errors: commentErrors } =
+							parser.parseCommentOptions(/** @type {Range} */ (expr.range));
+
+						if (commentErrors) {
+							for (const e of commentErrors) {
+								const { comment } = e;
+								parser.state.module.addWarning(
+									new CommentCompilationWarning(
+										`Compilation error while processing magic comment(-s): /*${comment.value}*/: ${e.message}`,
+										comment.loc
+									)
+								);
+							}
+						}
+
+						if (importOptions && importOptions.webpackIgnore !== undefined) {
+							if (typeof importOptions.webpackIgnore !== "boolean") {
+								parser.state.module.addWarning(
+									new UnsupportedFeatureWarning(
+										`\`webpackIgnore\` expected a boolean, but received: ${importOptions.webpackIgnore}.`,
+										/** @type {DependencyLocation} */ (expr.loc)
+									)
+								);
+								return;
+							} else if (importOptions.webpackIgnore) {
+								if (expr.arguments.length !== 2) return;
+
+								const [, arg2] = expr.arguments;
+
+								if (
+									arg2.type !== "MemberExpression" ||
+									!isMetaUrl(parser, arg2)
+								)
+									return;
+
+								const dep = new ConstDependency(
+									RuntimeGlobals.baseURI,
+									/** @type {Range} */ (arg2.range),
+									[RuntimeGlobals.baseURI]
+								);
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								parser.state.module.addPresentationalDependency(dep);
+
+								return true;
+							}
+						}
 
 						const request = getUrlRequest(expr);