webpack 5.68.0 → 5.70.0

package/lib/asset/AssetGenerator.js

@@ -12,6 +12,7 @@ const Generator = require("../Generator");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const createHash = require("../util/createHash");
 const { makePathsRelative } = require("../util/identifier");
+const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
@@ -112,6 +113,7 @@ const decodeDataUriContent = (encoding, content) => {
 
 const JS_TYPES = new Set(["javascript"]);
 const JS_AND_ASSET_TYPES = new Set(["javascript", "asset"]);
+const DEFAULT_ENCODING = "base64";
 
 class AssetGenerator extends Generator {
 	/**
@@ -130,6 +132,65 @@ class AssetGenerator extends Generator {
 		this.emit = emit;
 	}
 
+	/**
+	 * @param {NormalModule} module module
+	 * @param {RuntimeTemplate} runtimeTemplate runtime template
+	 * @returns {string} source file name
+	 */
+	getSourceFileName(module, runtimeTemplate) {
+		return makePathsRelative(
+			runtimeTemplate.compilation.compiler.context,
+			module.matchResource || module.resource,
+			runtimeTemplate.compilation.compiler.root
+		).replace(/^\.\//, "");
+	}
+
+	/**
+	 * @param {NormalModule} module module
+	 * @returns {string} mime type
+	 */
+	getMimeType(module) {
+		if (typeof this.dataUrlOptions === "function") {
+			throw new Error(
+				"This method must not be called when dataUrlOptions is a function"
+			);
+		}
+
+		let mimeType = this.dataUrlOptions.mimetype;
+		if (mimeType === undefined) {
+			const ext = path.extname(module.nameForCondition());
+			if (
+				module.resourceResolveData &&
+				module.resourceResolveData.mimetype !== undefined
+			) {
+				mimeType =
+					module.resourceResolveData.mimetype +
+					module.resourceResolveData.parameters;
+			} else if (ext) {
+				mimeType = mimeTypes.lookup(ext);
+
+				if (typeof mimeType !== "string") {
+					throw new Error(
+						"DataUrl can't be generated automatically, " +
+							`because there is no mimetype for "${ext}" in mimetype database. ` +
+							'Either pass a mimetype via "generator.mimetype" or ' +
+							'use type: "asset/resource" to create a resource file instead of a DataUrl'
+					);
+				}
+			}
+		}
+
+		if (typeof mimeType !== "string") {
+			throw new Error(
+				"DataUrl can't be generated automatically. " +
+					'Either pass a mimetype via "generator.mimetype" or ' +
+					'use type: "asset/resource" to create a resource file instead of a DataUrl'
+			);
+		}
+
+		return mimeType;
+	}
+
 	/**
 	 * @param {NormalModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
@@ -169,31 +230,9 @@ class AssetGenerator extends Generator {
 							}
 						}
 						if (encoding === undefined) {
-							encoding = "base64";
-						}
-						let ext;
-						let mimeType = this.dataUrlOptions.mimetype;
-						if (mimeType === undefined) {
-							ext = path.extname(module.nameForCondition());
-							if (
-								module.resourceResolveData &&
-								module.resourceResolveData.mimetype !== undefined
-							) {
-								mimeType =
-									module.resourceResolveData.mimetype +
-									module.resourceResolveData.parameters;
-							} else if (ext) {
-								mimeType = mimeTypes.lookup(ext);
-							}
-						}
-						if (typeof mimeType !== "string") {
-							throw new Error(
-								"DataUrl can't be generated automatically, " +
-									`because there is no mimetype for "${ext}" in mimetype database. ` +
-									'Either pass a mimetype via "generator.mimetype" or ' +
-									'use type: "asset/resource" to create a resource file instead of a DataUrl'
-							);
+							encoding = DEFAULT_ENCODING;
 						}
+						const mimeType = this.getMimeType(module);
 
 						let encodedContent;
 
@@ -232,16 +271,15 @@ class AssetGenerator extends Generator {
 					const fullHash = /** @type {string} */ (
 						hash.digest(runtimeTemplate.outputOptions.hashDigest)
 					);
-					const contentHash = fullHash.slice(
-						0,
+					const contentHash = nonNumericOnlyHash(
+						fullHash,
 						runtimeTemplate.outputOptions.hashDigestLength
 					);
 					module.buildInfo.fullContentHash = fullHash;
-					const sourceFilename = makePathsRelative(
-						runtimeTemplate.compilation.compiler.context,
-						module.matchResource || module.resource,
-						runtimeTemplate.compilation.compiler.root
-					).replace(/^\.\//, "");
+					const sourceFilename = this.getSourceFileName(
+						module,
+						runtimeTemplate
+					);
 					let { path: filename, info: assetInfo } =
 						runtimeTemplate.compilation.getAssetPathWithInfo(
 							assetModuleFilename,
@@ -367,8 +405,59 @@ class AssetGenerator extends Generator {
 	 * @param {Hash} hash hash that will be modified
 	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
-	updateHash(hash, { module }) {
-		hash.update(module.buildInfo.dataUrl ? "data-url" : "resource");
+	updateHash(hash, { module, runtime, runtimeTemplate, chunkGraph }) {
+		if (module.buildInfo.dataUrl) {
+			hash.update("data-url");
+			// this.dataUrlOptions as function should be pure and only depend on input source and filename
+			// therefore it doesn't need to be hashed
+			if (typeof this.dataUrlOptions === "function") {
+				const ident = /** @type {{ ident?: string }} */ (this.dataUrlOptions)
+					.ident;
+				if (ident) hash.update(ident);
+			} else {
+				if (
+					this.dataUrlOptions.encoding &&
+					this.dataUrlOptions.encoding !== DEFAULT_ENCODING
+				) {
+					hash.update(this.dataUrlOptions.encoding);
+				}
+				if (this.dataUrlOptions.mimetype)
+					hash.update(this.dataUrlOptions.mimetype);
+				// computed mimetype depends only on module filename which is already part of the hash
+			}
+		} else {
+			hash.update("resource");
+
+			const pathData = {
+				module,
+				runtime,
+				filename: this.getSourceFileName(module, runtimeTemplate),
+				chunkGraph,
+				contentHash: runtimeTemplate.contentHashReplacement
+			};
+
+			if (typeof this.publicPath === "function") {
+				hash.update("path");
+				const assetInfo = {};
+				hash.update(this.publicPath(pathData, assetInfo));
+				hash.update(JSON.stringify(assetInfo));
+			} else if (this.publicPath) {
+				hash.update("path");
+				hash.update(this.publicPath);
+			} else {
+				hash.update("no-path");
+			}
+
+			const assetModuleFilename =
+				this.filename || runtimeTemplate.outputOptions.assetModuleFilename;
+			const { path: filename, info } =
+				runtimeTemplate.compilation.getAssetPathWithInfo(
+					assetModuleFilename,
+					pathData
+				);
+			hash.update(filename);
+			hash.update(JSON.stringify(info));
+		}
 	}
 }
 

package/lib/buildChunkGraph.js

@@ -905,7 +905,7 @@ const visitModules = (
 										const module = it.value;
 										if (
 											availableModules.has(module) ||
-											availableModules.plus.has(m)
+											availableModules.plus.has(module)
 										) {
 											cachedMinAvailableModules.add(module);
 										}

package/lib/cache/ResolverCachePlugin.js

@@ -128,6 +128,13 @@ class ResolverCachePlugin {
 				fileDependencies: new LazySet(),
 				contextDependencies: new LazySet()
 			};
+			let yieldResult;
+			let withYield = false;
+			if (typeof newResolveContext.yield === "function") {
+				yieldResult = [];
+				withYield = true;
+				newResolveContext.yield = obj => yieldResult.push(obj);
+			}
 			const propagate = key => {
 				if (resolveContext[key]) {
 					addAllToSet(resolveContext[key], newResolveContext[key]);
@@ -155,15 +162,22 @@ class ResolverCachePlugin {
 						snapshotOptions,
 						(err, snapshot) => {
 							if (err) return callback(err);
+							const resolveResult = withYield ? yieldResult : result;
+							// since we intercept resolve hook
+							// we still can get result in callback
+							if (withYield && result) yieldResult.push(result);
 							if (!snapshot) {
-								if (result) return callback(null, result);
+								if (resolveResult) return callback(null, resolveResult);
 								return callback();
 							}
-							itemCache.store(new CacheEntry(result, snapshot), storeErr => {
-								if (storeErr) return callback(storeErr);
-								if (result) return callback(null, result);
-								callback();
-							});
+							itemCache.store(
+								new CacheEntry(resolveResult, snapshot),
+								storeErr => {
+									if (storeErr) return callback(storeErr);
+									if (resolveResult) return callback(null, resolveResult);
+									callback();
+								}
+							);
 						}
 					);
 				}
@@ -173,6 +187,8 @@ class ResolverCachePlugin {
 			factory(type, hook) {
 				/** @type {Map<string, (function(Error=, Object=): void)[]>} */
 				const activeRequests = new Map();
+				/** @type {Map<string, [function(Error=, Object=): void, function(Error=, Object=): void][]>} */
+				const activeRequestsWithYield = new Map();
 				hook.tap(
 					"ResolverCachePlugin",
 					/**
@@ -197,29 +213,67 @@ class ResolverCachePlugin {
 								if (request._ResolverCachePluginCacheMiss || !fileSystemInfo) {
 									return callback();
 								}
-								const identifier = `${type}${optionsIdent}${objectToString(
-									request,
-									!cacheWithContext
-								)}`;
-								const activeRequest = activeRequests.get(identifier);
-								if (activeRequest) {
-									activeRequest.push(callback);
-									return;
+								const withYield = typeof resolveContext.yield === "function";
+								const identifier = `${type}${
+									withYield ? "|yield" : "|default"
+								}${optionsIdent}${objectToString(request, !cacheWithContext)}`;
+
+								if (withYield) {
+									const activeRequest = activeRequestsWithYield.get(identifier);
+									if (activeRequest) {
+										activeRequest[0].push(callback);
+										activeRequest[1].push(resolveContext.yield);
+										return;
+									}
+								} else {
+									const activeRequest = activeRequests.get(identifier);
+									if (activeRequest) {
+										activeRequest.push(callback);
+										return;
+									}
 								}
 								const itemCache = cache.getItemCache(identifier, null);
-								let callbacks;
-								const done = (err, result) => {
-									if (callbacks === undefined) {
-										callback(err, result);
-										callbacks = false;
-									} else {
-										for (const callback of callbacks) {
-											callback(err, result);
-										}
-										activeRequests.delete(identifier);
-										callbacks = false;
-									}
-								};
+								let callbacks, yields;
+								const done = withYield
+									? (err, result) => {
+											if (callbacks === undefined) {
+												if (err) {
+													callback(err);
+												} else {
+													if (result)
+														for (const r of result) resolveContext.yield(r);
+													callback(null, null);
+												}
+												yields = undefined;
+												callbacks = false;
+											} else {
+												if (err) {
+													for (const cb of callbacks) cb(err);
+												} else {
+													for (let i = 0; i < callbacks.length; i++) {
+														const cb = callbacks[i];
+														const yield_ = yields[i];
+														if (result) for (const r of result) yield_(r);
+														cb(null, null);
+													}
+												}
+												activeRequestsWithYield.delete(identifier);
+												yields = undefined;
+												callbacks = false;
+											}
+									  }
+									: (err, result) => {
+											if (callbacks === undefined) {
+												callback(err, result);
+												callbacks = false;
+											} else {
+												for (const callback of callbacks) {
+													callback(err, result);
+												}
+												activeRequests.delete(identifier);
+												callbacks = false;
+											}
+									  };
 								/**
 								 * @param {Error=} err error if any
 								 * @param {CacheEntry=} cacheEntry cache entry
@@ -276,7 +330,14 @@ class ResolverCachePlugin {
 									}
 								};
 								itemCache.get(processCacheResult);
-								if (callbacks === undefined) {
+								if (withYield && callbacks === undefined) {
+									callbacks = [callback];
+									yields = [resolveContext.yield];
+									activeRequestsWithYield.set(
+										identifier,
+										/** @type {[any, any]} */ ([callbacks, yields])
+									);
+								} else if (callbacks === undefined) {
 									callbacks = [callback];
 									activeRequests.set(identifier, callbacks);
 								}

package/lib/config/browserslistTargetHandler.js

@@ -121,8 +121,7 @@ const resolve = browsers => {
 		// baidu: Not supported
 		// and_uc: Not supported
 		// kaios: Not supported
-		// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
-		node: [13, 14]
+		node: [12, 17]
 	});
 
 	return {
@@ -248,8 +247,7 @@ const resolve = browsers => {
 			// baidu: Not supported
 			// and_uc: Not supported
 			// kaios: Not supported
-			// Since Node.js 13.14.0 no warning about usage, but it was added 8.5.0 with some limitations and it was improved in 12.0.0 and 13.2.0
-			node: [13, 14]
+			node: [12, 17]
 		}),
 		dynamicImport: es6DynamicImport,
 		dynamicImportInWorker: es6DynamicImport && !anyNode,
@@ -272,7 +270,7 @@ const resolve = browsers => {
 			// baidu: Unknown support
 			// and_uc: Unknown support
 			// kaios: Unknown support
-			node: [12, 0]
+			node: 12
 		}),
 		optionalChaining: rawChecker({
 			chrome: 80,

package/lib/config/defaults.js

@@ -907,6 +907,7 @@ const applyOutputDefaults = (
 	D(output, "strictModuleExceptionHandling", false);
 
 	const optimistic = v => v || v === undefined;
+	const conditionallyOptimistic = (v, c) => (v === undefined && c) || v;
 	F(
 		output.environment,
 		"arrowFunction",
@@ -920,8 +921,12 @@ const applyOutputDefaults = (
 	);
 	F(output.environment, "forOf", () => tp && optimistic(tp.forOf));
 	F(output.environment, "bigIntLiteral", () => tp && tp.bigIntLiteral);
-	F(output.environment, "dynamicImport", () => tp && tp.dynamicImport);
-	F(output.environment, "module", () => tp && tp.module);
+	F(output.environment, "dynamicImport", () =>
+		conditionallyOptimistic(tp && tp.dynamicImport, output.module)
+	);
+	F(output.environment, "module", () =>
+		conditionallyOptimistic(tp && tp.module, output.module)
+	);
 
 	const { trustedTypes } = output;
 	if (trustedTypes) {

package/lib/config/normalization.js

@@ -488,6 +488,7 @@ const getNormalizedEntryStatic = entry => {
 				filename: value.filename,
 				layer: value.layer,
 				runtime: value.runtime,
+				baseUri: value.baseUri,
 				publicPath: value.publicPath,
 				chunkLoading: value.chunkLoading,
 				asyncChunks: value.asyncChunks,

package/lib/css/CssLoadingRuntimeModule.js

@@ -274,78 +274,71 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 			"",
 			withLoading
 				? Template.asString([
-						`${fn}.css = ${runtimeTemplate.basicFunction(
-							"chunkId, promises",
-							hasCssMatcher !== false
-								? [
-										"// css chunk loading",
-										`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-										'if(installedChunkData !== 0) { // 0 means "already installed".',
-										Template.indent([
-											"",
-											'// a Promise means "currently loading".',
-											"if(installedChunkData) {",
-											Template.indent([
-												"promises.push(installedChunkData[2]);"
-											]),
-											"} else {",
-											Template.indent([
-												hasCssMatcher === true
-													? "if(true) { // all chunks have CSS"
-													: `if(${hasCssMatcher("chunkId")}) {`,
+						`${fn}.css = ${runtimeTemplate.basicFunction("chunkId, promises", [
+							"// css chunk loading",
+							`var installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
+							'if(installedChunkData !== 0) { // 0 means "already installed".',
+							Template.indent([
+								"",
+								'// a Promise means "currently loading".',
+								"if(installedChunkData) {",
+								Template.indent(["promises.push(installedChunkData[2]);"]),
+								"} else {",
+								Template.indent([
+									hasCssMatcher === true
+										? "if(true) { // all chunks have CSS"
+										: `if(${hasCssMatcher("chunkId")}) {`,
+									Template.indent([
+										"// setup Promise in chunk cache",
+										`var promise = new Promise(${runtimeTemplate.expressionFunction(
+											`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
+											"resolve, reject"
+										)});`,
+										"promises.push(installedChunkData[2] = promise);",
+										"",
+										"// start chunk loading",
+										`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
+										"// create error before stack unwound to get useful stacktrace later",
+										"var error = new Error();",
+										`var loadingEnded = ${runtimeTemplate.basicFunction(
+											"event",
+											[
+												`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
 												Template.indent([
-													"// setup Promise in chunk cache",
-													`var promise = new Promise(${runtimeTemplate.expressionFunction(
-														`installedChunkData = installedChunks[chunkId] = [resolve, reject]`,
-														"resolve, reject"
-													)});`,
-													"promises.push(installedChunkData[2] = promise);",
-													"",
-													"// start chunk loading",
-													`var url = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkCssFilename}(chunkId);`,
-													"// create error before stack unwound to get useful stacktrace later",
-													"var error = new Error();",
-													`var loadingEnded = ${runtimeTemplate.basicFunction(
-														"event",
-														[
-															`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId)) {`,
-															Template.indent([
-																"installedChunkData = installedChunks[chunkId];",
-																"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
-																"if(installedChunkData) {",
-																Template.indent([
-																	'if(event.type !== "load") {',
-																	Template.indent([
-																		"var errorType = event && event.type;",
-																		"var realSrc = event && event.target && event.target.src;",
-																		"error.message = 'Loading css chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
-																		"error.name = 'ChunkLoadError';",
-																		"error.type = errorType;",
-																		"error.request = realSrc;",
-																		"installedChunkData[1](error);"
-																	]),
-																	"} else {",
-																	Template.indent([
-																		`loadCssChunkData(${RuntimeGlobals.moduleFactories}, link, chunkId);`,
-																		"installedChunkData[0]();"
-																	]),
-																	"}"
-																]),
-																"}"
-															]),
-															"}"
-														]
-													)};`,
-													"var link = loadStylesheet(chunkId, url, loadingEnded);"
+													"installedChunkData = installedChunks[chunkId];",
+													"if(installedChunkData !== 0) installedChunks[chunkId] = undefined;",
+													"if(installedChunkData) {",
+													Template.indent([
+														'if(event.type !== "load") {',
+														Template.indent([
+															"var errorType = event && event.type;",
+															"var realSrc = event && event.target && event.target.src;",
+															"error.message = 'Loading css chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';",
+															"error.name = 'ChunkLoadError';",
+															"error.type = errorType;",
+															"error.request = realSrc;",
+															"installedChunkData[1](error);"
+														]),
+														"} else {",
+														Template.indent([
+															`loadCssChunkData(${RuntimeGlobals.moduleFactories}, link, chunkId);`,
+															"installedChunkData[0]();"
+														]),
+														"}"
+													]),
+													"}"
 												]),
-												"} else installedChunks[chunkId] = 0;"
-											]),
-											"}"
-										]),
-										"}"
-								  ]
-								: "installedChunks[chunkId] = 0;"
-						)};`
+												"}"
+											]
+										)};`,
+										"var link = loadStylesheet(chunkId, url, loadingEnded);"
+									]),
+									"} else installedChunks[chunkId] = 0;"
+								]),
+								"}"
+							]),
+							"}"
+						])};`
 				  ])
 				: "// no chunk loading",
 			"",

package/lib/css/CssModulesPlugin.js

@@ -19,6 +19,7 @@ const { compareModulesByIdentifier } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
 const memoize = require("../util/memoize");
+const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 const CssExportsGenerator = require("./CssExportsGenerator");
 const CssGenerator = require("./CssGenerator");
 const CssParser = require("./CssParser");
@@ -201,7 +202,7 @@ class CssModulesPlugin {
 						hash.update(chunkGraph.getModuleHash(module, chunk.runtime));
 					}
 					const digest = /** @type {string} */ (hash.digest(hashDigest));
-					chunk.contentHash.css = digest.substr(0, hashDigestLength);
+					chunk.contentHash.css = nonNumericOnlyHash(digest, hashDigestLength);
 				});
 				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
 					const { chunkGraph } = compilation;

package/lib/debug/ProfilingPlugin.js

@@ -343,7 +343,8 @@ const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
 };
 
 const makeInterceptorFor = (instance, tracer) => hookName => ({
-	register: ({ name, type, context, fn }) => {
+	register: tapInfo => {
+		const { name, type, fn } = tapInfo;
 		const newFn =
 			// Don't tap our own hooks to ensure stream can close cleanly
 			name === pluginName
@@ -354,9 +355,7 @@ const makeInterceptorFor = (instance, tracer) => hookName => ({
 						fn
 				  });
 		return {
-			name,
-			type,
-			context,
+			...tapInfo,
 			fn: newFn
 		};
 	}

package/lib/dependencies/ContextDependencyHelpers.js

@@ -37,7 +37,7 @@ const splitContextFromPrefix = prefix => {
 	};
 };
 
-/** @typedef {Partial<Omit<ContextDependencyOptions, "resource"|"recursive"|"regExp">>} PartialContextDependencyOptions */
+/** @typedef {Partial<Omit<ContextDependencyOptions, "resource">>} PartialContextDependencyOptions */
 
 /** @typedef {{ new(options: ContextDependencyOptions, range: [number, number], valueRange: [number, number]): ContextDependency }} ContextDependencyConstructor */
 

package/lib/dependencies/ContextElementDependency.js

@@ -53,12 +53,18 @@ class ContextElementDependency extends ModuleDependency {
 	}
 
 	serialize(context) {
-		context.write(this.referencedExports);
+		const { write } = context;
+		write(this._typePrefix);
+		write(this._category);
+		write(this.referencedExports);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
-		this.referencedExports = context.read();
+		const { read } = context;
+		this._typePrefix = read();
+		this._category = read();
+		this.referencedExports = read();
 		super.deserialize(context);
 	}
 }

package/lib/dependencies/ExportsInfoDependency.js

@@ -46,6 +46,12 @@ const getProperty = (moduleGraph, module, exportName, property, runtime) => {
 		}
 	}
 	switch (property) {
+		case "canMangle": {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const exportInfo = exportsInfo.getExportInfo(exportName);
+			if (exportInfo) return exportInfo.canMangle;
+			return exportsInfo.otherExportsInfo.canMangle;
+		}
 		case "used":
 			return (
 				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==