webpack 5.70.0 → 5.72.1

package/lib/NormalModule.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const parseJson = require("json-parse-better-errors");
+const parseJson = require("json-parse-even-better-errors");
 const { getContext, runLoaders } = require("loader-runner");
 const querystring = require("querystring");
 const { HookMap, SyncHook, AsyncSeriesBailHook } = require("tapable");
@@ -375,7 +375,7 @@ class NormalModule extends Module {
 	nameForCondition() {
 		const resource = this.matchResource || this.resource;
 		const idx = resource.indexOf("?");
-		if (idx >= 0) return resource.substr(0, idx);
+		if (idx >= 0) return resource.slice(0, idx);
 		return resource;
 	}
 
@@ -558,7 +558,7 @@ class NormalModule extends Module {
 				let { options } = loader;
 
 				if (typeof options === "string") {
-					if (options.substr(0, 1) === "{" && options.substr(-1) === "}") {
+					if (options.startsWith("{") && options.endsWith("}")) {
 						try {
 							options = parseJson(options);
 						} catch (e) {
@@ -1176,7 +1176,8 @@ class NormalModule extends Module {
 		chunkGraph,
 		runtime,
 		concatenationScope,
-		codeGenerationResults
+		codeGenerationResults,
+		sourceTypes
 	}) {
 		/** @type {Set<string>} */
 		const runtimeRequirements = new Set();
@@ -1195,7 +1196,7 @@ class NormalModule extends Module {
 		};
 
 		const sources = new Map();
-		for (const type of this.generator.getTypes(this)) {
+		for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) {
 			const source = this.error
 				? new RawSource(
 						"throw new Error(" + JSON.stringify(this.error.message) + ");"

package/lib/NormalModuleFactory.js

@@ -379,7 +379,7 @@ class NormalModuleFactory extends ModuleFactory {
 							resource: matchResource,
 							...cacheParseResource(matchResource)
 						};
-						requestWithoutMatchResource = request.substr(
+						requestWithoutMatchResource = request.slice(
 							matchResourceMatch[0].length
 						);
 					}
@@ -437,7 +437,7 @@ class NormalModuleFactory extends ModuleFactory {
 					try {
 						for (const item of loaders) {
 							if (typeof item.options === "string" && item.options[0] === "?") {
-								const ident = item.options.substr(1);
+								const ident = item.options.slice(1);
 								if (ident === "[[missing ident]]") {
 									throw new Error(
 										"No ident is provided by referenced loader. " +

package/lib/RuntimePlugin.js

@@ -11,6 +11,7 @@ const RuntimeRequirementsDependency = require("./dependencies/RuntimeRequirement
 const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 const AsyncModuleRuntimeModule = require("./runtime/AsyncModuleRuntimeModule");
 const AutoPublicPathRuntimeModule = require("./runtime/AutoPublicPathRuntimeModule");
+const BaseUriRuntimeModule = require("./runtime/BaseUriRuntimeModule");
 const CompatGetDefaultExportRuntimeModule = require("./runtime/CompatGetDefaultExportRuntimeModule");
 const CompatRuntimeModule = require("./runtime/CompatRuntimeModule");
 const CreateFakeNamespaceObjectRuntimeModule = require("./runtime/CreateFakeNamespaceObjectRuntimeModule");
@@ -25,6 +26,7 @@ const GlobalRuntimeModule = require("./runtime/GlobalRuntimeModule");
 const HasOwnPropertyRuntimeModule = require("./runtime/HasOwnPropertyRuntimeModule");
 const LoadScriptRuntimeModule = require("./runtime/LoadScriptRuntimeModule");
 const MakeNamespaceObjectRuntimeModule = require("./runtime/MakeNamespaceObjectRuntimeModule");
+const NonceRuntimeModule = require("./runtime/NonceRuntimeModule");
 const OnChunksLoadedRuntimeModule = require("./runtime/OnChunksLoadedRuntimeModule");
 const PublicPathRuntimeModule = require("./runtime/PublicPathRuntimeModule");
 const RelativeUrlRuntimeModule = require("./runtime/RelativeUrlRuntimeModule");
@@ -96,6 +98,15 @@ class RuntimePlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap("RuntimePlugin", compilation => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			const isChunkLoadingDisabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === false;
+			};
 			compilation.dependencyTemplates.set(
 				RuntimeRequirementsDependency,
 				new RuntimeRequirementsDependency.Template()
@@ -413,6 +424,20 @@ class RuntimePlugin {
 					);
 					return true;
 				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.baseURI)
+				.tap("RuntimePlugin", chunk => {
+					if (isChunkLoadingDisabledForChunk(chunk)) {
+						compilation.addRuntimeModule(chunk, new BaseUriRuntimeModule());
+						return true;
+					}
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.scriptNonce)
+				.tap("RuntimePlugin", chunk => {
+					compilation.addRuntimeModule(chunk, new NonceRuntimeModule());
+					return true;
+				});
 			// TODO webpack 6: remove CompatRuntimeModule
 			compilation.hooks.additionalTreeRuntimeRequirements.tap(
 				"RuntimePlugin",

package/lib/asset/AssetGenerator.js

@@ -8,6 +8,7 @@
 const mimeTypes = require("mime-types");
 const path = require("path");
 const { RawSource } = require("webpack-sources");
+const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const createHash = require("../util/createHash");
@@ -23,6 +24,7 @@ const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Generator").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../util/Hash")} Hash */
@@ -145,6 +147,15 @@ class AssetGenerator extends Generator {
 		).replace(/^\.\//, "");
 	}
 
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
+	}
+
 	/**
 	 * @param {NormalModule} module module
 	 * @returns {string} mime type
@@ -198,14 +209,21 @@ class AssetGenerator extends Generator {
 	 */
 	generate(
 		module,
-		{ runtime, chunkGraph, runtimeTemplate, runtimeRequirements, type, getData }
+		{
+			runtime,
+			concatenationScope,
+			chunkGraph,
+			runtimeTemplate,
+			runtimeRequirements,
+			type,
+			getData
+		}
 	) {
 		switch (type) {
 			case "asset":
 				return module.originalSource();
 			default: {
-				runtimeRequirements.add(RuntimeGlobals.module);
-
+				let content;
 				const originalSource = module.originalSource();
 				if (module.buildInfo.dataUrl) {
 					let encodedSource;
@@ -255,11 +273,7 @@ class AssetGenerator extends Generator {
 					}
 					const data = getData();
 					data.set("url", Buffer.from(encodedSource));
-					return new RawSource(
-						`${RuntimeGlobals.module}.exports = ${JSON.stringify(
-							encodedSource
-						)};`
-					);
+					content = JSON.stringify(encodedSource);
 				} else {
 					const assetModuleFilename =
 						this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
@@ -343,9 +357,22 @@ class AssetGenerator extends Generator {
 						data.set("filename", filename);
 						data.set("assetInfo", assetInfo);
 					}
+					content = assetPath;
+				}
 
+				if (concatenationScope) {
+					concatenationScope.registerNamespaceExport(
+						ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+					);
+					return new RawSource(
+						`${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+							ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+						} = ${content};`
+					);
+				} else {
+					runtimeRequirements.add(RuntimeGlobals.module);
 					return new RawSource(
-						`${RuntimeGlobals.module}.exports = ${assetPath};`
+						`${RuntimeGlobals.module}.exports = ${content};`
 					);
 				}
 			}

package/lib/asset/AssetParser.js

@@ -31,6 +31,7 @@ class AssetParser extends Parser {
 		}
 		state.module.buildInfo.strict = true;
 		state.module.buildMeta.exportsType = "default";
+		state.module.buildMeta.defaultObject = false;
 
 		if (typeof this.dataUrlCondition === "function") {
 			state.module.buildInfo.dataUrl = this.dataUrlCondition(source, {

package/lib/asset/AssetSourceGenerator.js

@@ -6,11 +6,13 @@
 "use strict";
 
 const { RawSource } = require("webpack-sources");
+const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
+/** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../NormalModule")} NormalModule */
 
 const TYPES = new Set(["javascript"]);
@@ -21,9 +23,10 @@ class AssetSourceGenerator extends Generator {
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source} generated code
 	 */
-	generate(module, { chunkGraph, runtimeTemplate, runtimeRequirements }) {
-		runtimeRequirements.add(RuntimeGlobals.module);
-
+	generate(
+		module,
+		{ concatenationScope, chunkGraph, runtimeTemplate, runtimeRequirements }
+	) {
 		const originalSource = module.originalSource();
 
 		if (!originalSource) {
@@ -38,9 +41,31 @@ class AssetSourceGenerator extends Generator {
 		} else {
 			encodedSource = content.toString("utf-8");
 		}
-		return new RawSource(
-			`${RuntimeGlobals.module}.exports = ${JSON.stringify(encodedSource)};`
-		);
+
+		let sourceContent;
+		if (concatenationScope) {
+			concatenationScope.registerNamespaceExport(
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			);
+			sourceContent = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
+			} = ${JSON.stringify(encodedSource)};`;
+		} else {
+			runtimeRequirements.add(RuntimeGlobals.module);
+			sourceContent = `${RuntimeGlobals.module}.exports = ${JSON.stringify(
+				encodedSource
+			)};`;
+		}
+		return new RawSource(sourceContent);
+	}
+
+	/**
+	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {ConcatenationBailoutReasonContext} context context
+	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
+	 */
+	getConcatenationBailoutReason(module, context) {
+		return undefined;
 	}
 
 	/**

package/lib/asset/AssetSourceParser.js

@@ -23,6 +23,7 @@ class AssetSourceParser extends Parser {
 		const { module } = state;
 		module.buildInfo.strict = true;
 		module.buildMeta.exportsType = "default";
+		state.module.buildMeta.defaultObject = false;
 
 		return state;
 	}

package/lib/cache/PackFileCacheStrategy.js

@@ -639,10 +639,14 @@ class PackContentItems {
 				} catch (e) {
 					rollback(s);
 					if (e === NOT_SERIALIZABLE) continue;
-					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
-					);
-					logger.debug(e.stack);
+					const msg = "Skipped not serializable cache item";
+					if (e.message.includes("ModuleBuildError")) {
+						logger.log(`${msg} (in build error): ${e.message}`);
+						logger.debug(`${msg} '${key}' (in build error): ${e.stack}`);
+					} else {
+						logger.warn(`${msg}: ${e.message}`);
+						logger.debug(`${msg} '${key}': ${e.stack}`);
+					}
 				}
 			}
 			write(null);

package/lib/config/defaults.js

@@ -715,7 +715,15 @@ const applyOutputDefaults = (
 	};
 
 	F(output, "uniqueName", () => {
-		const libraryName = getLibraryName(output.library);
+		const libraryName = getLibraryName(output.library).replace(
+			/^\[(\\*[\w:]+\\*)\](\.)|(\.)\[(\\*[\w:]+\\*)\](?=\.|$)|\[(\\*[\w:]+\\*)\]/g,
+			(m, a, d1, d2, b, c) => {
+				const content = a || b || c;
+				return content.startsWith("\\") && content.endsWith("\\")
+					? `${d2 || ""}[${content.slice(1, -1)}]${d1 || ""}`
+					: "";
+			}
+		);
 		if (libraryName) return libraryName;
 		const pkgPath = path.resolve(context, "package.json");
 		try {

package/lib/container/RemoteRuntimeModule.js

@@ -73,9 +73,9 @@ class RemoteRuntimeModule extends RuntimeModule {
 							Template.indent(
 								`error.message += '\\nwhile loading "' + data[1] + '" from ' + data[2];`
 							),
-							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction("", [
-								"throw error;"
-							])}`,
+							`${
+								RuntimeGlobals.moduleFactories
+							}[id] = ${runtimeTemplate.basicFunction("", ["throw error;"])}`,
 							"data.p = 0;"
 						])};`,
 						`var handleFunction = ${runtimeTemplate.basicFunction(
@@ -111,10 +111,11 @@ class RemoteRuntimeModule extends RuntimeModule {
 						)};`,
 						`var onFactory = ${runtimeTemplate.basicFunction("factory", [
 							"data.p = 1;",
-							`__webpack_modules__[id] = ${runtimeTemplate.basicFunction(
-								"module",
-								["module.exports = factory();"]
-							)}`
+							`${
+								RuntimeGlobals.moduleFactories
+							}[id] = ${runtimeTemplate.basicFunction("module", [
+								"module.exports = factory();"
+							])}`
 						])};`,
 						"handleFunction(__webpack_require__, data[2], 0, 0, onExternal, 1);"
 					])});`

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -201,7 +201,7 @@ class CommonJsExportsParserPlugin {
 				if (expr.arguments[1].type === "SpreadElement") return;
 				if (expr.arguments[2].type === "SpreadElement") return;
 				const exportsArg = parser.evaluateExpression(expr.arguments[0]);
-				if (!exportsArg || !exportsArg.isIdentifier()) return;
+				if (!exportsArg.isIdentifier()) return;
 				if (
 					exportsArg.identifier !== "exports" &&
 					exportsArg.identifier !== "module.exports" &&
@@ -210,7 +210,6 @@ class CommonJsExportsParserPlugin {
 					return;
 				}
 				const propertyArg = parser.evaluateExpression(expr.arguments[1]);
-				if (!propertyArg) return;
 				const property = propertyArg.asString();
 				if (typeof property !== "string") return;
 				enableStructuredExports();

package/lib/dependencies/ContextDependencyHelpers.js

@@ -28,8 +28,8 @@ const splitContextFromPrefix = prefix => {
 	const idx = prefix.lastIndexOf("/");
 	let context = ".";
 	if (idx >= 0) {
-		context = prefix.substr(0, idx);
-		prefix = `.${prefix.substr(idx)}`;
+		context = prefix.slice(0, idx);
+		prefix = `.${prefix.slice(idx)}`;
 	}
 	return {
 		context,

package/lib/dependencies/ContextElementDependency.js

@@ -14,11 +14,27 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 class ContextElementDependency extends ModuleDependency {
-	constructor(request, userRequest, typePrefix, category, referencedExports) {
+	/**
+	 * @param {string} request request
+	 * @param {string|undefined} userRequest user request
+	 * @param {string} typePrefix type prefix
+	 * @param {string} category category
+	 * @param {string[][]=} referencedExports referenced exports
+	 * @param {string=} context context
+	 */
+	constructor(
+		request,
+		userRequest,
+		typePrefix,
+		category,
+		referencedExports,
+		context
+	) {
 		super(request);
 		this.referencedExports = referencedExports;
 		this._typePrefix = typePrefix;
 		this._category = category;
+		this._context = context || undefined;
 
 		if (userRequest) {
 			this.userRequest = userRequest;
@@ -33,6 +49,20 @@ 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;
 	}
@@ -56,6 +86,7 @@ class ContextElementDependency extends ModuleDependency {
 		const { write } = context;
 		write(this._typePrefix);
 		write(this._category);
+		write(this._context);
 		write(this.referencedExports);
 		super.serialize(context);
 	}
@@ -64,6 +95,7 @@ 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

@@ -0,0 +1,127 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const makeSerializable = require("../util/makeSerializable");
+const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+/**
+ * Dependency for static evaluating import specifier. e.g.
+ * @example
+ * import a from "a";
+ * "x" in a;
+ * a.x !== undefined; // if x value statically analyzable
+ */
+class HarmonyEvaluatedImportSpecifierDependency extends HarmonyImportSpecifierDependency {
+	constructor(request, sourceOrder, ids, name, range, assertions, operator) {
+		super(request, sourceOrder, ids, name, range, false, assertions);
+		this.operator = operator;
+	}
+
+	get type() {
+		return `evaluated X ${this.operator} harmony import specifier`;
+	}
+
+	serialize(context) {
+		super.serialize(context);
+		const { write } = context;
+		write(this.operator);
+	}
+
+	deserialize(context) {
+		super.deserialize(context);
+		const { read } = context;
+		this.operator = read();
+	}
+}
+
+makeSerializable(
+	HarmonyEvaluatedImportSpecifierDependency,
+	"webpack/lib/dependencies/HarmonyEvaluatedImportSpecifierDependency"
+);
+
+HarmonyEvaluatedImportSpecifierDependency.Template = class HarmonyEvaluatedImportSpecifierDependencyTemplate extends (
+	HarmonyImportSpecifierDependency.Template
+) {
+	/**
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const dep = /** @type {HarmonyEvaluatedImportSpecifierDependency} */ (
+			dependency
+		);
+		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);
+
+		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}`);
+		} else {
+			const usedName = exportsInfo.getUsedName(ids, runtime);
+
+			const code = this._getCodeForIds(
+				dep,
+				source,
+				templateContext,
+				ids.slice(0, -1)
+			);
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				`${
+					usedName ? JSON.stringify(usedName[usedName.length - 1]) : '""'
+				} in ${code}`
+			);
+		}
+	}
+};
+
+module.exports = HarmonyEvaluatedImportSpecifierDependency;