webpack 5.97.1 → 5.99.0

package/lib/dependencies/JsonExportsDependency.js

@@ -14,46 +14,66 @@ 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("../json/JsonData").JsonValue} JsonValue */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
 
 /**
- * @param {RawJsonData} data data
- * @returns {TODO} value
+ * @callback GetExportsFromDataFn
+ * @param {JsonValue} data raw json data
+ * @param {number} [curDepth] current depth
+ * @returns {ExportSpec[] | null} export spec or nothing
  */
-const getExportsFromData = data => {
-	if (data && typeof data === "object") {
-		if (Array.isArray(data)) {
-			return data.length < 100
-				? data.map((item, idx) => ({
-						name: `${idx}`,
-						canMangle: true,
-						exports: getExportsFromData(item)
-					}))
-				: undefined;
+
+/**
+ * @param {number} exportsDepth exportsDepth
+ * @returns {GetExportsFromDataFn} value
+ */
+const getExportsWithDepth = exportsDepth =>
+	/** @type {GetExportsFromDataFn} */
+	function getExportsFromData(data, curDepth = 1) {
+		if (curDepth > exportsDepth) {
+			return null;
 		}
-		const exports = [];
-		for (const key of Object.keys(data)) {
-			exports.push({
-				name: key,
-				canMangle: true,
-				exports: getExportsFromData(data[key])
-			});
+
+		if (data && typeof data === "object") {
+			if (Array.isArray(data)) {
+				return data.length < 100
+					? data.map((item, idx) => ({
+							name: `${idx}`,
+							canMangle: true,
+							exports: getExportsFromData(item, curDepth + 1) || undefined
+						}))
+					: null;
+			}
+
+			/** @type {ExportSpec[]} */
+			const exports = [];
+
+			for (const key of Object.keys(data)) {
+				exports.push({
+					name: key,
+					canMangle: true,
+					exports: getExportsFromData(data[key], curDepth + 1) || undefined
+				});
+			}
+
+			return exports;
 		}
-		return exports;
-	}
-	return undefined;
-};
+
+		return null;
+	};
 
 class JsonExportsDependency extends NullDependency {
 	/**
 	 * @param {JsonData} data json data
+	 * @param {number} exportsDepth the depth of json exports to analyze
 	 */
-	constructor(data) {
+	constructor(data, exportsDepth) {
 		super();
 		this.data = data;
+		this.exportsDepth = exportsDepth;
 	}
 
 	get type() {
@@ -67,8 +87,8 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	getExports(moduleGraph) {
 		return {
-			exports: getExportsFromData(
-				this.data && /** @type {RawJsonData} */ (this.data.get())
+			exports: getExportsWithDepth(this.exportsDepth)(
+				this.data && /** @type {JsonValue} */ (this.data.get())
 			),
 			dependencies: undefined
 		};
@@ -90,6 +110,7 @@ class JsonExportsDependency extends NullDependency {
 	serialize(context) {
 		const { write } = context;
 		write(this.data);
+		write(this.exportsDepth);
 		super.serialize(context);
 	}
 
@@ -99,6 +120,7 @@ class JsonExportsDependency extends NullDependency {
 	deserialize(context) {
 		const { read } = context;
 		this.data = read();
+		this.exportsDepth = read();
 		super.deserialize(context);
 	}
 }

package/lib/dependencies/LoaderPlugin.js

@@ -12,6 +12,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
 
 /** @typedef {import("../../declarations/LoaderContext").LoaderPluginLoaderContext} LoaderPluginLoaderContext */
 /** @typedef {import("../Compilation").DepConstructor} DepConstructor */
+/** @typedef {import("../Compilation").ExecuteModuleExports} ExecuteModuleExports */
 /** @typedef {import("../Compilation").ExecuteModuleResult} ExecuteModuleResult */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -20,7 +21,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
 /**
  * @callback ImportModuleCallback
  * @param {(Error | null)=} err error object
- * @param {any=} exports exports of the evaluated module
+ * @param {ExecuteModuleExports=} exports exports of the evaluated module
  */
 
 /**
@@ -31,11 +32,6 @@ const LoaderImportDependency = require("./LoaderImportDependency");
  */
 
 class LoaderPlugin {
-	/**
-	 * @param {object} options options
-	 */
-	constructor(options = {}) {}
-
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -150,12 +146,7 @@ class LoaderPlugin {
 								for (const d of buildDependencies) {
 									loaderContext.addBuildDependency(d);
 								}
-								return callback(
-									null,
-									source,
-									/** @type {object | null} */ (map),
-									referencedModule
-								);
+								return callback(null, source, map, referencedModule);
 							}
 						);
 					};
@@ -271,8 +262,7 @@ class LoaderPlugin {
 						);
 					};
 
-					// eslint-disable-next-line no-warning-comments
-					// @ts-ignore Overloading doesn't work
+					// @ts-expect-error overloading doesn't work
 					loaderContext.importModule = (request, options, callback) => {
 						if (!callback) {
 							return new Promise((resolve, reject) => {

package/lib/dependencies/RequireContextDependency.js

@@ -10,10 +10,11 @@ const ContextDependency = require("./ContextDependency");
 const ModuleDependencyTemplateAsRequireId = require("./ModuleDependencyTemplateAsRequireId");
 
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("./ContextDependency").ContextDependencyOptions} ContextDependencyOptions */
 
 class RequireContextDependency extends ContextDependency {
 	/**
-	 * @param {TODO} options options
+	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 */
 	constructor(options, range) {

package/lib/dependencies/RequireContextDependencyParserPlugin.js

@@ -7,6 +7,7 @@
 
 const RequireContextDependency = require("./RequireContextDependency");
 
+/** @typedef {import("../ContextModule").ContextMode} ContextMode */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../javascript/JavascriptParser").Range} Range */
@@ -22,12 +23,13 @@ module.exports = class RequireContextDependencyParserPlugin {
 			.tap("RequireContextDependencyParserPlugin", expr => {
 				let regExp = /^\.\/.*$/;
 				let recursive = true;
+				/** @type {ContextMode} */
 				let mode = "sync";
 				switch (expr.arguments.length) {
 					case 4: {
 						const modeExpr = parser.evaluateExpression(expr.arguments[3]);
 						if (!modeExpr.isString()) return;
-						mode = /** @type {string} */ (modeExpr.string);
+						mode = /** @type {ContextMode} */ (modeExpr.string);
 					}
 					// falls through
 					case 3: {
@@ -47,13 +49,14 @@ module.exports = class RequireContextDependencyParserPlugin {
 						if (!requestExpr.isString()) return;
 						const dep = new RequireContextDependency(
 							{
-								request: requestExpr.string,
+								request: /** @type {string} */ (requestExpr.string),
 								recursive,
 								regExp,
 								mode,
 								category: "commonjs"
 							},
-							/** @type {Range} */ (expr.range)
+							/** @type {Range} */
+							(expr.range)
 						);
 						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						dep.optional = Boolean(parser.scope.inTry);

package/lib/dependencies/RequireEnsureDependenciesBlock.js

@@ -8,13 +8,14 @@
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const makeSerializable = require("../util/makeSerializable");
 
+/** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
 /** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 
 class RequireEnsureDependenciesBlock extends AsyncDependenciesBlock {
 	/**
-	 * @param {ChunkGroupOptions & { entryOptions?: TODO }} chunkName chunk name
-	 * @param {DependencyLocation} loc location info
+	 * @param {GroupOptions | null} chunkName chunk name
+	 * @param {(DependencyLocation | null)=} loc location info
 	 */
 	constructor(chunkName, loc) {
 		super(chunkName, loc, null);

package/lib/dependencies/RequireEnsureDependenciesBlockParserPlugin.js

@@ -10,6 +10,7 @@ const RequireEnsureDependency = require("./RequireEnsureDependency");
 const RequireEnsureItemDependency = require("./RequireEnsureItemDependency");
 const getFunctionExpression = require("./getFunctionExpression");
 
+/** @typedef {import("../AsyncDependenciesBlock").GroupOptions} GroupOptions */
 /** @typedef {import("../ChunkGroup").ChunkGroupOptions} ChunkGroupOptions */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
@@ -25,6 +26,7 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 		parser.hooks.call
 			.for("require.ensure")
 			.tap("RequireEnsureDependenciesBlockParserPlugin", expr => {
+				/** @type {string | GroupOptions | null} */
 				let chunkName = null;
 				let errorExpressionArg = null;
 				let errorExpression = null;
@@ -32,7 +34,9 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 					case 4: {
 						const chunkNameExpr = parser.evaluateExpression(expr.arguments[3]);
 						if (!chunkNameExpr.isString()) return;
-						chunkName = chunkNameExpr.string;
+						chunkName =
+							/** @type {string} */
+							(chunkNameExpr.string);
 					}
 					// falls through
 					case 3: {
@@ -44,7 +48,9 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 								expr.arguments[2]
 							);
 							if (!chunkNameExpr.isString()) return;
-							chunkName = chunkNameExpr.string;
+							chunkName =
+								/** @type {string} */
+								(chunkNameExpr.string);
 						}
 					}
 					// falls through
@@ -70,9 +76,9 @@ module.exports = class RequireEnsureDependenciesBlockParserPlugin {
 						}
 
 						const depBlock = new RequireEnsureDependenciesBlock(
-							/** @type {ChunkGroupOptions & { entryOptions?: TODO }} */
-							(chunkName),
-							/** @type {DependencyLocation} */ (expr.loc)
+							chunkName,
+							/** @type {DependencyLocation} */
+							(expr.loc)
 						);
 						const errorCallbackExists =
 							expr.arguments.length === 4 ||

package/lib/dependencies/RequireResolveContextDependency.js

@@ -19,7 +19,7 @@ class RequireResolveContextDependency extends ContextDependency {
 	 * @param {ContextDependencyOptions} options options
 	 * @param {Range} range range
 	 * @param {Range} valueRange value range
-	 * @param {TODO} context context
+	 * @param {string=} context context
 	 */
 	constructor(options, range, valueRange, context) {
 		super(options, context);

package/lib/dependencies/WebAssemblyExportImportedDependency.js

@@ -21,7 +21,7 @@ class WebAssemblyExportImportedDependency extends ModuleDependency {
 	 * @param {string} exportName export name
 	 * @param {string} request request
 	 * @param {string} name name
-	 * @param {TODO} valueType value type
+	 * @param {string} valueType value type
 	 */
 	constructor(exportName, request, name, valueType) {
 		super(request);

package/lib/dependencies/WorkerDependency.js

@@ -30,6 +30,7 @@ class WorkerDependency extends ModuleDependency {
 	 * @param {Range} range range
 	 * @param {object} workerDependencyOptions options
 	 * @param {string=} workerDependencyOptions.publicPath public path for the worker
+	 * @param {boolean=} workerDependencyOptions.needNewUrl need generate `new URL(...)`
 	 */
 	constructor(request, range, workerDependencyOptions) {
 		super(request);
@@ -118,12 +119,14 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 		runtimeRequirements.add(RuntimeGlobals.baseURI);
 		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
 
+		const workerImportStr = `/* worker import */ ${workerImportBaseUrl} + ${
+			RuntimeGlobals.getChunkScriptFilename
+		}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`;
+
 		source.replace(
 			dep.range[0],
 			dep.range[1] - 1,
-			`/* worker import */ ${workerImportBaseUrl} + ${
-				RuntimeGlobals.getChunkScriptFilename
-			}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`
+			dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
 		);
 	}
 };

package/lib/dependencies/WorkerPlugin.js

@@ -27,6 +27,8 @@ const WorkerDependency = require("./WorkerDependency");
 
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").Identifier} Identifier */
+/** @typedef {import("estree").MemberExpression} MemberExpression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").Property} Property */
@@ -117,45 +119,81 @@ class WorkerPlugin {
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {Expression} expr expression
-				 * @returns {[BasicEvaluatedExpression, [number, number]] | void} parsed
+				 * @returns {[string, [number, number]] | void} parsed
 				 */
 				const parseModuleUrl = (parser, expr) => {
-					if (
-						expr.type !== "NewExpression" ||
-						expr.callee.type === "Super" ||
-						expr.arguments.length !== 2
-					)
+					if (expr.type !== "NewExpression" || expr.callee.type === "Super")
 						return;
-					const [arg1, arg2] = expr.arguments;
-					if (arg1.type === "SpreadElement") return;
-					if (arg2.type === "SpreadElement") return;
-					const callee = parser.evaluateExpression(expr.callee);
-					if (!callee.isIdentifier() || callee.identifier !== "URL") return;
-					const arg2Value = parser.evaluateExpression(arg2);
 					if (
-						!arg2Value.isString() ||
-						!(/** @type {string} */ (arg2Value.string).startsWith("file://")) ||
-						arg2Value.string !== getUrl(parser.state.module)
+						expr.arguments.length === 1 &&
+						expr.arguments[0].type === "MemberExpression" &&
+						isMetaUrl(parser, expr.arguments[0])
 					) {
-						return;
+						const arg1 = expr.arguments[0];
+						return [
+							getUrl(parser.state.module),
+							[
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg1.range)[1]
+							]
+						];
+					} else if (expr.arguments.length === 2) {
+						const [arg1, arg2] = expr.arguments;
+						if (arg1.type === "SpreadElement") return;
+						if (arg2.type === "SpreadElement") return;
+						const callee = parser.evaluateExpression(expr.callee);
+						if (!callee.isIdentifier() || callee.identifier !== "URL") return;
+						const arg2Value = parser.evaluateExpression(arg2);
+						if (
+							!arg2Value.isString() ||
+							!(
+								/** @type {string} */ (arg2Value.string).startsWith("file://")
+							) ||
+							arg2Value.string !== getUrl(parser.state.module)
+						) {
+							return;
+						}
+						const arg1Value = parser.evaluateExpression(arg1);
+						if (!arg1Value.isString()) return;
+						return [
+							/** @type {string} */ (arg1Value.string),
+							[
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg2.range)[1]
+							]
+						];
 					}
-					const arg1Value = parser.evaluateExpression(arg1);
-					return [
-						arg1Value,
-						[
-							/** @type {Range} */ (arg1.range)[0],
-							/** @type {Range} */ (arg2.range)[1]
-						]
-					];
 				};
 
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @param {MemberExpression} expr expression
+				 * @returns {boolean} is `import.meta.url`
+				 */
+				const isMetaUrl = (parser, expr) => {
+					const chain = parser.extractMemberExpressionChain(expr);
+
+					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;
+				};
+
+				/** @typedef {Record<string, EXPECTED_ANY>} Values */
+
 				/**
 				 * @param {JavascriptParser} parser the parser
 				 * @param {ObjectExpression} expr expression
-				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Record<string, any>, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
+				 * @returns {{ expressions: Record<string, Expression | Pattern>, otherElements: (Property | SpreadElement)[], values: Values, spread: boolean, insertType: "comma" | "single", insertLocation: number }} parsed object
 				 */
 				const parseObjectExpression = (parser, expr) => {
-					/** @type {Record<string, any>} */
+					/** @type {Values} */
 					const values = {};
 					/** @type {Record<string, Expression | Pattern>} */
 					const expressions = {};
@@ -174,7 +212,8 @@ class WorkerPlugin {
 							expressions[prop.key.name] = prop.value;
 							if (!prop.shorthand && !prop.value.type.endsWith("Pattern")) {
 								const value = parser.evaluateExpression(
-									/** @type {Expression} */ (prop.value)
+									/** @type {Expression} */
+									(prop.value)
 								);
 								if (value.isCompileTimeValue())
 									values[prop.key.name] = value.asCompileTimeValue();
@@ -217,10 +256,27 @@ class WorkerPlugin {
 						const [arg1, arg2] = expr.arguments;
 						if (arg1.type === "SpreadElement") return;
 						if (arg2 && arg2.type === "SpreadElement") return;
-						const parsedUrl = parseModuleUrl(parser, arg1);
-						if (!parsedUrl) return;
-						const [url, range] = parsedUrl;
-						if (!url.isString()) return;
+
+						/** @type {string} */
+						let url;
+						/** @type {[number, number]} */
+						let range;
+						/** @type {boolean} */
+						let needNewUrl = false;
+
+						if (arg1.type === "MemberExpression" && isMetaUrl(parser, arg1)) {
+							url = getUrl(parser.state.module);
+							range = [
+								/** @type {Range} */ (arg1.range)[0],
+								/** @type {Range} */ (arg1.range)[1]
+							];
+							needNewUrl = true;
+						} else {
+							const parsedUrl = parseModuleUrl(parser, arg1);
+							if (!parsedUrl) return;
+							[url, range] = parsedUrl;
+						}
+
 						const {
 							expressions,
 							otherElements,
@@ -234,7 +290,7 @@ class WorkerPlugin {
 									/** @type {Record<string, Expression | Pattern>} */
 									expressions: {},
 									otherElements: [],
-									/** @type {Record<string, any>} */
+									/** @type {Values} */
 									values: {},
 									spread: false,
 									insertType: arg2 ? "spread" : "argument",
@@ -342,13 +398,10 @@ class WorkerPlugin {
 							}
 						});
 						block.loc = expr.loc;
-						const dep = new WorkerDependency(
-							/** @type {string} */ (url.string),
-							range,
-							{
-								publicPath: this._workerPublicPath
-							}
-						);
+						const dep = new WorkerDependency(url, range, {
+							publicPath: this._workerPublicPath,
+							needNewUrl
+						});
 						dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 						block.addDependency(dep);
 						parser.state.module.addBlock(block);
@@ -370,7 +423,7 @@ class WorkerPlugin {
 								);
 								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 								parser.state.module.addPresentationalDependency(dep);
-								/** @type {TODO} */
+								/** @type {EXPECTED_ANY} */
 								(expressions).type = undefined;
 							}
 						} else if (insertType === "comma") {
@@ -406,7 +459,13 @@ class WorkerPlugin {
 
 						parser.walkExpression(expr.callee);
 						for (const key of Object.keys(expressions)) {
-							if (expressions[key]) parser.walkExpression(expressions[key]);
+							if (expressions[key]) {
+								if (expressions[key].type.endsWith("Pattern")) continue;
+								parser.walkExpression(
+									/** @type {Expression} */
+									(expressions[key])
+								);
+							}
 						}
 						for (const prop of otherElements) {
 							parser.walkProperty(prop);

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -151,6 +151,11 @@ class ModuleChunkFormatPlugin {
 								let index = 0;
 								for (let i = 0; i < entries.length; i++) {
 									const [module, entrypoint] = entries[i];
+									if (
+										!chunkGraph.getModuleSourceTypes(module).has("javascript")
+									) {
+										continue;
+									}
 									const final = i + 1 === entries.length;
 									const moduleId = chunkGraph.getModuleId(module);
 									const chunks = getAllChunks(

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -93,7 +93,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			(compilation.outputOptions.environment);
 		const {
 			runtimeTemplate,
-			outputOptions: { importFunctionName, crossOriginLoading }
+			outputOptions: { importFunctionName, crossOriginLoading, charset }
 		} = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
@@ -261,6 +261,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							linkPrefetch.call(
 								Template.asString([
 									"var link = document.createElement('link');",
+									charset ? "link.charset = 'utf-8';" : "",
 									crossOriginLoading
 										? `link.crossOrigin = ${JSON.stringify(
 												crossOriginLoading
@@ -300,7 +301,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							linkPreload.call(
 								Template.asString([
 									"var link = document.createElement('link');",
-									"link.charset = 'utf-8';",
+									charset ? "link.charset = 'utf-8';" : "",
 									`if (${RuntimeGlobals.scriptNonce}) {`,
 									Template.indent(
 										`link.setAttribute("nonce", ${RuntimeGlobals.scriptNonce});`

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -69,6 +69,7 @@ module.exports = function () {
 					me.children.push(request);
 				}
 			} else {
+				// eslint-disable-next-line no-console
 				console.warn(
 					"[HMR] unexpected require(" +
 						request +

package/lib/hmr/JavascriptHotModuleReplacement.runtime.js

@@ -109,6 +109,7 @@ module.exports = function () {
 		var appliedUpdate = {};
 
 		var warnUnexpectedRequire = function warnUnexpectedRequire(module) {
+			// eslint-disable-next-line no-console
 			console.warn(
 				"[HMR] unexpected require(" + module.id + ") to disposed module"
 			);