webpack 5.71.0 → 5.73.0

package/lib/dependencies/ContextElementDependency.js

@@ -49,20 +49,6 @@ class ContextElementDependency extends ModuleDependency {
 		return "context element";
 	}
 
-	/**
-	 * @returns {string | undefined} a request context
-	 */
-	getContext() {
-		return this._context;
-	}
-
-	/**
-	 * @returns {string | null} an identifier to merge equal requests
-	 */
-	getResourceIdentifier() {
-		return `context${this._context || ""}|${super.getResourceIdentifier()}`;
-	}
-
 	get category() {
 		return this._category;
 	}
@@ -86,7 +72,6 @@ class ContextElementDependency extends ModuleDependency {
 		const { write } = context;
 		write(this._typePrefix);
 		write(this._category);
-		write(this._context);
 		write(this.referencedExports);
 		super.serialize(context);
 	}
@@ -95,7 +80,6 @@ class ContextElementDependency extends ModuleDependency {
 		const { read } = context;
 		this._typePrefix = read();
 		this._category = read();
-		this._context = read();
 		this.referencedExports = read();
 		super.deserialize(context);
 	}

package/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency.js

@@ -61,17 +61,49 @@ HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImpor
 		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
 			dependency
 		);
-		const { moduleGraph, runtime } = templateContext;
+		const { module, moduleGraph, runtime } = templateContext;
 		const connection = moduleGraph.getConnection(dep);
 		// Skip rendering depending when dependency is conditional
 		if (connection && !connection.isTargetActive(runtime)) return;
 
 		const exportsInfo = moduleGraph.getExportsInfo(connection.module);
 		const ids = dep.getIds(moduleGraph);
-		const value = exportsInfo.isExportProvided(ids);
+
+		let value;
+
+		const exportsType = connection.module.getExportsType(
+			moduleGraph,
+			module.buildMeta.strictHarmonyModule
+		);
+		switch (exportsType) {
+			case "default-with-named": {
+				if (ids[0] === "default") {
+					value =
+						ids.length === 1 || exportsInfo.isExportProvided(ids.slice(1));
+				} else {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			case "namespace": {
+				if (ids[0] === "__esModule") {
+					value = ids.length === 1 || undefined;
+				} else {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			case "dynamic": {
+				if (ids[0] !== "default") {
+					value = exportsInfo.isExportProvided(ids);
+				}
+				break;
+			}
+			// default-only could lead to runtime error, when default value is primitive
+		}
 
 		if (typeof value === "boolean") {
-			source.replace(dep.range[0], dep.range[1] - 1, `${value}`);
+			source.replace(dep.range[0], dep.range[1] - 1, ` ${value}`);
 		} else {
 			const usedName = exportsInfo.getUsedName(ids, runtime);
 

package/lib/dependencies/ImportParserPlugin.js

@@ -14,10 +14,14 @@ const ImportDependency = require("./ImportDependency");
 const ImportEagerDependency = require("./ImportEagerDependency");
 const ImportWeakDependency = require("./ImportWeakDependency");
 
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../ContextModule").ContextMode} ContextMode */
 
 class ImportParserPlugin {
+	/**
+	 * @param {JavascriptParserOptions} options options
+	 */
 	constructor(options) {
 		this.options = options;
 	}
@@ -28,7 +32,7 @@ class ImportParserPlugin {
 
 			let chunkName = null;
 			/** @type {ContextMode} */
-			let mode = "lazy";
+			let mode = this.options.dynamicImportMode;
 			let include = null;
 			let exclude = null;
 			/** @type {string[][] | null} */
@@ -36,6 +40,17 @@ class ImportParserPlugin {
 			/** @type {RawChunkGroupOptions} */
 			const groupOptions = {};
 
+			const { dynamicImportPreload, dynamicImportPrefetch } = this.options;
+			if (dynamicImportPreload !== undefined && dynamicImportPreload !== false)
+				groupOptions.preloadOrder =
+					dynamicImportPreload === true ? 0 : dynamicImportPreload;
+			if (
+				dynamicImportPrefetch !== undefined &&
+				dynamicImportPrefetch !== false
+			)
+				groupOptions.prefetchOrder =
+					dynamicImportPrefetch === true ? 0 : dynamicImportPrefetch;
+
 			const { options: importOptions, errors: commentErrors } =
 				parser.parseCommentOptions(expr.range);
 
@@ -175,16 +190,22 @@ class ImportParserPlugin {
 				}
 			}
 
-			if (param.isString()) {
-				if (mode !== "lazy" && mode !== "eager" && mode !== "weak") {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-				}
+			if (
+				mode !== "lazy" &&
+				mode !== "lazy-once" &&
+				mode !== "eager" &&
+				mode !== "weak"
+			) {
+				parser.state.module.addWarning(
+					new UnsupportedFeatureWarning(
+						`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
+						expr.loc
+					)
+				);
+				mode = "lazy";
+			}
 
+			if (param.isString()) {
 				if (mode === "eager") {
 					const dep = new ImportEagerDependency(
 						param.string,
@@ -215,21 +236,6 @@ class ImportParserPlugin {
 				}
 				return true;
 			} else {
-				if (
-					mode !== "lazy" &&
-					mode !== "lazy-once" &&
-					mode !== "eager" &&
-					mode !== "weak"
-				) {
-					parser.state.module.addWarning(
-						new UnsupportedFeatureWarning(
-							`\`webpackMode\` expected 'lazy', 'lazy-once', 'eager' or 'weak', but received: ${mode}.`,
-							expr.loc
-						)
-					);
-					mode = "lazy";
-				}
-
 				if (mode === "weak") {
 					mode = "async-weak";
 				}

package/lib/dependencies/JsonExportsDependency.js

@@ -13,18 +13,21 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../json/JsonData")} JsonData */
 /** @typedef {import("../util/Hash")} Hash */
 
 const getExportsFromData = data => {
 	if (data && typeof data === "object") {
 		if (Array.isArray(data)) {
-			return data.map((item, idx) => {
-				return {
-					name: `${idx}`,
-					canMangle: true,
-					exports: getExportsFromData(item)
-				};
-			});
+			return data.length < 100
+				? data.map((item, idx) => {
+						return {
+							name: `${idx}`,
+							canMangle: true,
+							exports: getExportsFromData(item)
+						};
+				  })
+				: undefined;
 		} else {
 			const exports = [];
 			for (const key of Object.keys(data)) {
@@ -42,12 +45,11 @@ const getExportsFromData = data => {
 
 class JsonExportsDependency extends NullDependency {
 	/**
-	 * @param {(string | ExportSpec)[]} exports json exports
+	 * @param {JsonData=} data json data
 	 */
-	constructor(exports) {
+	constructor(data) {
 		super();
-		this.exports = exports;
-		this._hashUpdate = undefined;
+		this.data = data;
 	}
 
 	get type() {
@@ -61,7 +63,7 @@ class JsonExportsDependency extends NullDependency {
 	 */
 	getExports(moduleGraph) {
 		return {
-			exports: this.exports,
+			exports: getExportsFromData(this.data && this.data.get()),
 			dependencies: undefined
 		};
 	}
@@ -73,23 +75,18 @@ class JsonExportsDependency extends NullDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		if (this._hashUpdate === undefined) {
-			this._hashUpdate = this.exports
-				? JSON.stringify(this.exports)
-				: "undefined";
-		}
-		hash.update(this._hashUpdate);
+		this.data.updateHash(hash);
 	}
 
 	serialize(context) {
 		const { write } = context;
-		write(this.exports);
+		write(this.data);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
 		const { read } = context;
-		this.exports = read();
+		this.data = read();
 		super.deserialize(context);
 	}
 }
@@ -100,4 +97,3 @@ makeSerializable(
 );
 
 module.exports = JsonExportsDependency;
-module.exports.getExportsFromData = getExportsFromData;

package/lib/dependencies/LoaderDependency.js

@@ -7,6 +7,11 @@
 
 const ModuleDependency = require("./ModuleDependency");
 
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
 class LoaderDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request string
@@ -22,6 +27,14 @@ class LoaderDependency extends ModuleDependency {
 	get category() {
 		return "loader";
 	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return false;
+	}
 }
 
 module.exports = LoaderDependency;

package/lib/dependencies/LoaderImportDependency.js

@@ -7,6 +7,11 @@
 
 const ModuleDependency = require("./ModuleDependency");
 
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
+/** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
 class LoaderImportDependency extends ModuleDependency {
 	/**
 	 * @param {string} request request string
@@ -23,6 +28,14 @@ class LoaderImportDependency extends ModuleDependency {
 	get category() {
 		return "loaderImport";
 	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | function(ModuleGraphConnection, RuntimeSpec): ConnectionState} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		return false;
+	}
 }
 
 module.exports = LoaderImportDependency;

package/lib/dependencies/ModuleDependency.js

@@ -26,13 +26,21 @@ class ModuleDependency extends Dependency {
 		// assertions must be serialized by subclasses that use it
 		/** @type {Record<string, any> | undefined} */
 		this.assertions = undefined;
+		this._context = undefined;
+	}
+
+	/**
+	 * @returns {string | undefined} a request context
+	 */
+	getContext() {
+		return this._context;
 	}
 
 	/**
 	 * @returns {string | null} an identifier to merge equal requests
 	 */
 	getResourceIdentifier() {
-		let str = `module${this.request}`;
+		let str = `context${this._context || ""}|module${this.request}`;
 		if (this.assertions !== undefined) {
 			str += JSON.stringify(this.assertions);
 		}
@@ -63,6 +71,7 @@ class ModuleDependency extends Dependency {
 		const { write } = context;
 		write(this.request);
 		write(this.userRequest);
+		write(this._context);
 		write(this.range);
 		super.serialize(context);
 	}
@@ -71,6 +80,7 @@ class ModuleDependency extends Dependency {
 		const { read } = context;
 		this.request = read();
 		this.userRequest = read();
+		this._context = read();
 		this.range = read();
 		super.deserialize(context);
 	}

package/lib/dependencies/RequireResolveContextDependency.js

@@ -10,8 +10,8 @@ const ContextDependency = require("./ContextDependency");
 const ContextDependencyTemplateAsId = require("./ContextDependencyTemplateAsId");
 
 class RequireResolveContextDependency extends ContextDependency {
-	constructor(options, range, valueRange) {
-		super(options);
+	constructor(options, range, valueRange, context) {
+		super(options, context);
 
 		this.range = range;
 		this.valueRange = valueRange;

package/lib/dependencies/RequireResolveDependency.js

@@ -15,10 +15,11 @@ const ModuleDependencyAsId = require("./ModuleDependencyTemplateAsId");
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class RequireResolveDependency extends ModuleDependency {
-	constructor(request, range) {
+	constructor(request, range, context) {
 		super(request);
 
 		this.range = range;
+		this._context = context;
 	}
 
 	get type() {

package/lib/dependencies/URLPlugin.js

@@ -5,12 +5,15 @@
 
 "use strict";
 
+const { pathToFileURL } = require("url");
+const BasicEvaluatedExpression = require("../javascript/BasicEvaluatedExpression");
 const { approve } = require("../javascript/JavascriptParserHelpers");
 const InnerGraph = require("../optimize/InnerGraph");
 const URLDependency = require("./URLDependency");
 
 /** @typedef {import("estree").NewExpression} NewExpressionNode */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 
 class URLPlugin {
@@ -27,6 +30,13 @@ class URLPlugin {
 					new URLDependency.Template()
 				);
 
+				/**
+				 * @param {NormalModule} module module
+				 * @returns {URL} file url
+				 */
+				const getUrl = module => {
+					return pathToFileURL(module.resource);
+				};
 				/**
 				 * @param {JavascriptParser} parser parser
 				 * @param {object} parserOptions options
@@ -67,6 +77,17 @@ class URLPlugin {
 					};
 
 					parser.hooks.canRename.for("URL").tap("URLPlugin", approve);
+					parser.hooks.evaluateNewExpression
+						.for("URL")
+						.tap("URLPlugin", expr => {
+							const request = getUrlRequest(expr);
+							if (!request) return;
+							const url = new URL(request, getUrl(parser.state.module));
+
+							return new BasicEvaluatedExpression()
+								.setString(url.toString())
+								.setRange(expr.range);
+						});
 					parser.hooks.new.for("URL").tap("URLPlugin", _expr => {
 						const expr = /** @type {NewExpressionNode} */ (_expr);
 

package/lib/index.js

@@ -28,6 +28,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./Compilation").Asset} Asset */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compilation").EntryOptions} EntryOptions */
+/** @typedef {import("./Compilation").PathData} PathData */
 /** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
 /** @typedef {import("./MultiStats")} MultiStats */
 /** @typedef {import("./Parser").ParserState} ParserState */

package/lib/javascript/JavascriptParser.js

@@ -165,6 +165,14 @@ class JavascriptParser extends Parser {
 			evaluateDefinedIdentifier: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
+			/** @type {HookMap<SyncBailHook<[NewExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateNewExpression: new HookMap(
+				() => new SyncBailHook(["expression"])
+			),
+			/** @type {HookMap<SyncBailHook<[CallExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateCallExpression: new HookMap(
+				() => new SyncBailHook(["expression"])
+			),
 			/** @type {HookMap<SyncBailHook<[CallExpressionNode, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
 			evaluateCallExpressionMember: new HookMap(
 				() => new SyncBailHook(["expression", "param"])
@@ -361,9 +369,14 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
 			const expr = /** @type {NewExpressionNode} */ (_expr);
 			const callee = expr.callee;
-			if (
-				callee.type !== "Identifier" ||
-				callee.name !== "RegExp" ||
+			if (callee.type !== "Identifier") return;
+			if (callee.name !== "RegExp") {
+				return this.callHooksForName(
+					this.hooks.evaluateNewExpression,
+					callee.name,
+					expr
+				);
+			} else if (
 				expr.arguments.length > 2 ||
 				this.getVariableInfo("RegExp") !== "RegExp"
 			)
@@ -1036,24 +1049,28 @@ class JavascriptParser extends Parser {
 		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
 			const expr = /** @type {CallExpressionNode} */ (_expr);
 			if (
-				expr.callee.type !== "MemberExpression" ||
-				expr.callee.property.type !==
+				expr.callee.type === "MemberExpression" &&
+				expr.callee.property.type ===
 					(expr.callee.computed ? "Literal" : "Identifier")
 			) {
-				return;
-			}
-
-			// type Super also possible here
-			const param = this.evaluateExpression(
-				/** @type {ExpressionNode} */ (expr.callee.object)
-			);
-			const property =
-				expr.callee.property.type === "Literal"
-					? `${expr.callee.property.value}`
-					: expr.callee.property.name;
-			const hook = this.hooks.evaluateCallExpressionMember.get(property);
-			if (hook !== undefined) {
-				return hook.call(expr, param);
+				// type Super also possible here
+				const param = this.evaluateExpression(
+					/** @type {ExpressionNode} */ (expr.callee.object)
+				);
+				const property =
+					expr.callee.property.type === "Literal"
+						? `${expr.callee.property.value}`
+						: expr.callee.property.name;
+				const hook = this.hooks.evaluateCallExpressionMember.get(property);
+				if (hook !== undefined) {
+					return hook.call(expr, param);
+				}
+			} else if (expr.callee.type === "Identifier") {
+				return this.callHooksForName(
+					this.hooks.evaluateCallExpression,
+					expr.callee.name,
+					expr
+				);
 			}
 		});
 		this.hooks.evaluateCallExpressionMember
@@ -3603,6 +3620,10 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	evaluatedVariable(tagInfo) {
+		return new VariableInfo(this.scope, undefined, tagInfo);
+	}
+
 	parseCommentOptions(range) {
 		const comments = this.getComments(range);
 		if (comments.length === 0) {

package/lib/json/JsonData.js

@@ -24,6 +24,14 @@ class JsonData {
 		}
 		return this._data;
 	}
+
+	updateHash(hash) {
+		if (this._buffer === undefined && this._data !== undefined) {
+			this._buffer = Buffer.from(JSON.stringify(this._data));
+		}
+
+		if (this._buffer) return hash.update(this._buffer);
+	}
 }
 
 register(JsonData, "webpack/lib/json/JsonData", null, {

package/lib/json/JsonParser.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const parseJson = require("json-parse-better-errors");
+const parseJson = require("json-parse-even-better-errors");
 const Parser = require("../Parser");
 const JsonExportsDependency = require("../dependencies/JsonExportsDependency");
 const JsonData = require("./JsonData");
@@ -41,15 +41,13 @@ class JsonParser extends Parser {
 			typeof source === "object"
 				? source
 				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
-
-		state.module.buildInfo.jsonData = new JsonData(data);
+		const jsonData = new JsonData(data);
+		state.module.buildInfo.jsonData = jsonData;
 		state.module.buildInfo.strict = true;
 		state.module.buildMeta.exportsType = "default";
 		state.module.buildMeta.defaultObject =
 			typeof data === "object" ? "redirect-warn" : false;
-		state.module.addDependency(
-			new JsonExportsDependency(JsonExportsDependency.getExportsFromData(data))
-		);
+		state.module.addDependency(new JsonExportsDependency(jsonData));
 		return state;
 	}
 }

package/lib/optimize/ConcatenatedModule.js

@@ -1669,7 +1669,8 @@ ${defineGetters}`
 					chunkGraph,
 					runtime,
 					concatenationScope,
-					codeGenerationResults
+					codeGenerationResults,
+					sourceTypes: TYPES
 				});
 				const source = codeGenResult.sources.get("javascript");
 				const data = codeGenResult.data;

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -58,6 +58,11 @@ class ModuleConcatenationPlugin {
 	apply(compiler) {
 		const { _backCompat: backCompat } = compiler;
 		compiler.hooks.compilation.tap("ModuleConcatenationPlugin", compilation => {
+			if (compilation.moduleMemCaches) {
+				throw new Error(
+					"optimization.concatenateModules can't be used with cacheUnaffected as module concatenation is a global effect"
+				);
+			}
 			const moduleGraph = compilation.moduleGraph;
 			const bailoutReasonMap = new Map();
 
@@ -425,7 +430,21 @@ class ModuleConcatenationPlugin {
 										for (const chunk of chunkGraph.getModuleChunksIterable(
 											rootModule
 										)) {
-											chunkGraph.disconnectChunkAndModule(chunk, m);
+											const sourceTypes = chunkGraph.getChunkModuleSourceTypes(
+												chunk,
+												m
+											);
+											if (sourceTypes.size === 1) {
+												chunkGraph.disconnectChunkAndModule(chunk, m);
+											} else {
+												const newSourceTypes = new Set(sourceTypes);
+												newSourceTypes.delete("javascript");
+												chunkGraph.setChunkModuleSourceTypes(
+													chunk,
+													m,
+													newSourceTypes
+												);
+											}
 										}
 									}
 								}
@@ -587,7 +606,7 @@ class ModuleConcatenationPlugin {
 				incomingConnectionsFromNonModules.filter(connection => {
 					// We are not interested in inactive connections
 					// or connections without dependency
-					return connection.isActive(runtime) || connection.dependency;
+					return connection.isActive(runtime);
 				});
 			if (activeNonModulesConnections.length > 0) {
 				const problem = requestShortener => {