webpack 5.14.0 → 5.18.0

package/lib/optimize/ConcatenatedModule.js

@@ -1650,18 +1650,6 @@ ${defineGetters}`
 		}
 	}
 
-	/**
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {DependencyTemplates} dependencyTemplates dependency templates
-	 * @param {RuntimeSpec} runtime the runtime
-	 * @returns {string} hash
-	 */
-	_getHashDigest(chunkGraph, dependencyTemplates, runtime) {
-		const hash = chunkGraph.getModuleHash(this, runtime);
-		const dtHash = dependencyTemplates.getHash();
-		return `${hash}-${dtHash}`;
-	}
-
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @param {RuntimeSpec} runtime the runtime

package/lib/optimize/InnerGraph.js

@@ -5,9 +5,14 @@
 
 "use strict";
 
+const { UsageState } = require("../ExportsInfo");
+
 /** @typedef {import("estree").Node} AnyNode */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /** @typedef {Map<TopLevelSymbol, Set<string | TopLevelSymbol> | true>} InnerGraph */
 /** @typedef {function(boolean | Set<string> | undefined): void} UsageCallback */
@@ -254,6 +259,33 @@ exports.tagTopLevelSymbol = (parser, name) => {
 	return fn;
 };
 
+/**
+ * @param {Dependency} dependency the dependency
+ * @param {Set<string> | boolean} usedByExports usedByExports info
+ * @param {ModuleGraph} moduleGraph moduleGraph
+ * @param {RuntimeSpec} runtime runtime
+ * @returns {boolean} false, when unused. Otherwise true
+ */
+exports.isDependencyUsedByExports = (
+	dependency,
+	usedByExports,
+	moduleGraph,
+	runtime
+) => {
+	if (usedByExports === false) return false;
+	if (usedByExports !== true && usedByExports !== undefined) {
+		const selfModule = moduleGraph.getParentModule(dependency);
+		const exportsInfo = moduleGraph.getExportsInfo(selfModule);
+		let used = false;
+		for (const exportName of usedByExports) {
+			if (exportsInfo.getUsed(exportName, runtime) !== UsageState.Unused)
+				used = true;
+		}
+		if (!used) return false;
+	}
+	return true;
+};
+
 class TopLevelSymbol {
 	/**
 	 * @param {string} name name of the variable

package/lib/optimize/SplitChunksPlugin.js

@@ -1298,7 +1298,10 @@ module.exports = class SplitChunksPlugin {
 								) {
 									continue;
 								}
-								if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
+								if (
+									item.chunks.size > 1 &&
+									chunkGraph.getNumberOfEntryModules(chunk) > 0
+								) {
 									continue;
 								}
 								for (const module of item.modules) {

package/lib/serialization/ObjectMiddleware.js

@@ -367,11 +367,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 				try {
 					process(value);
 				} catch (e) {
-					if (hasDebugInfoAttached === undefined)
-						hasDebugInfoAttached = new WeakSet();
-					if (!hasDebugInfoAttached.has(e)) {
-						e.message += `\nwhile serializing ${stackToString(value)}`;
-						hasDebugInfoAttached.add(e);
+					if (e !== NOT_SERIALIZABLE) {
+						if (hasDebugInfoAttached === undefined)
+							hasDebugInfoAttached = new WeakSet();
+						if (!hasDebugInfoAttached.has(e)) {
+							e.message += `\nwhile serializing ${stackToString(value)}`;
+							hasDebugInfoAttached.add(e);
+						}
 					}
 					throw e;
 				}

package/lib/sharing/ProvideSharedModule.js

@@ -143,7 +143,7 @@ class ProvideSharedModule extends Module {
 						request: this._request,
 						runtimeRequirements
 				  })
-		});`;
+		}${this._eager ? ", 1" : ""});`;
 		const sources = new Map();
 		const data = new Map();
 		data.set("share-init", [

package/lib/sharing/ShareRuntimeModule.js

@@ -83,11 +83,11 @@ class ShareRuntimeModule extends RuntimeModule {
 					)};`,
 					`var uniqueName = ${JSON.stringify(uniqueName || undefined)};`,
 					`var register = ${runtimeTemplate.basicFunction(
-						"name, version, factory",
+						"name, version, factory, eager",
 						[
 							"var versions = scope[name] = scope[name] || {};",
 							"var activeVersion = versions[version];",
-							"if(!activeVersion || !activeVersion.loaded && uniqueName > activeVersion.from) versions[version] = { get: factory, from: uniqueName };"
+							"if(!activeVersion || (!activeVersion.loaded && (!eager != !activeVersion.eager ? eager : uniqueName > activeVersion.from))) versions[version] = { get: factory, from: uniqueName, eager: !!eager };"
 						]
 					)};`,
 					`var initExternal = ${runtimeTemplate.basicFunction("id", [

package/lib/stats/DefaultStatsPresetPlugin.js

@@ -48,6 +48,7 @@ const NAMED_PRESETS = {
 		runtimeModules: true,
 		exclude: false,
 		modulesSpace: Infinity,
+		chunkModulesSpace: Infinity,
 		assetsSpace: Infinity,
 		children: true
 	},

package/lib/util/MapHelpers.js

@@ -0,0 +1,22 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @template K
+ * @template V
+ * @param {Map<K, V>} map a map
+ * @param {K} key the key
+ * @param {function(): V} computer compute value
+ * @returns {V} value
+ */
+exports.provide = (map, key, computer) => {
+	const value = map.get(key);
+	if (value !== undefined) return value;
+	const newValue = computer();
+	map.set(key, newValue);
+	return newValue;
+};

package/lib/util/binarySearchBounds.js

@@ -0,0 +1,86 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Mikola Lysenko @mikolalysenko
+*/
+
+"use strict";
+
+/* cspell:disable-next-line */
+// Refactor: Peter Somogyvari @petermetz
+
+const compileSearch = (funcName, predicate, reversed, extraArgs, earlyOut) => {
+	const code = [
+		"function ",
+		funcName,
+		"(a,l,h,",
+		extraArgs.join(","),
+		"){",
+		earlyOut ? "" : "var i=",
+		reversed ? "l-1" : "h+1",
+		";while(l<=h){var m=(l+h)>>>1,x=a[m]"
+	];
+
+	if (earlyOut) {
+		if (predicate.indexOf("c") < 0) {
+			code.push(";if(x===y){return m}else if(x<=y){");
+		} else {
+			code.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){");
+		}
+	} else {
+		code.push(";if(", predicate, "){i=m;");
+	}
+	if (reversed) {
+		code.push("l=m+1}else{h=m-1}");
+	} else {
+		code.push("h=m-1}else{l=m+1}");
+	}
+	code.push("}");
+	if (earlyOut) {
+		code.push("return -1};");
+	} else {
+		code.push("return i};");
+	}
+	return code.join("");
+};
+
+const compileBoundsSearch = (predicate, reversed, suffix, earlyOut) => {
+	const arg1 = compileSearch(
+		"A",
+		"x" + predicate + "y",
+		reversed,
+		["y"],
+		earlyOut
+	);
+
+	const arg2 = compileSearch(
+		"P",
+		"c(x,y)" + predicate + "0",
+		reversed,
+		["y", "c"],
+		earlyOut
+	);
+
+	const fnHeader = "function dispatchBinarySearch";
+
+	const fnBody =
+		"(a,y,c,l,h){\
+if(typeof(c)==='function'){\
+return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)\
+}else{\
+return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)\
+}}\
+return dispatchBinarySearch";
+
+	const fnArgList = [arg1, arg2, fnHeader, suffix, fnBody, suffix];
+	const fnSource = fnArgList.join("");
+	const result = new Function(fnSource);
+	return result();
+};
+
+module.exports = {
+	ge: compileBoundsSearch(">=", false, "GE"),
+	gt: compileBoundsSearch(">", false, "GT"),
+	lt: compileBoundsSearch("<", true, "LT"),
+	le: compileBoundsSearch("<=", true, "LE"),
+	eq: compileBoundsSearch("-", true, "EQ", true)
+};

package/lib/util/createHash.js

@@ -7,9 +7,11 @@
 
 const Hash = require("./Hash");
 
-const BULK_SIZE = 1000;
+const BULK_SIZE = 2000;
 
-const digestCache = new Map();
+// We are using an object instead of a Map as this will stay static during the runtime
+// so access to it can be optimized by v8
+const digestCaches = {};
 
 class BulkUpdateDecorator extends Hash {
 	/**
@@ -64,11 +66,15 @@ class BulkUpdateDecorator extends Hash {
 	 * @returns {string|Buffer} digest
 	 */
 	digest(encoding) {
-		let cacheKey;
+		let digestCache;
 		if (this.hash === undefined) {
 			// short data for hash, we can use caching
-			cacheKey = `${this.hashKey}-${encoding}-${this.buffer}`;
-			const cacheEntry = digestCache.get(cacheKey);
+			const cacheKey = `${this.hashKey}-${encoding}`;
+			digestCache = digestCaches[cacheKey];
+			if (digestCache === undefined) {
+				digestCache = digestCaches[cacheKey] = new Map();
+			}
+			const cacheEntry = digestCache.get(this.buffer);
 			if (cacheEntry !== undefined) return cacheEntry;
 			this.hash = this.hashFactory();
 		}
@@ -78,8 +84,8 @@ class BulkUpdateDecorator extends Hash {
 		const digestResult = this.hash.digest(encoding);
 		const result =
 			typeof digestResult === "string" ? digestResult : digestResult.toString();
-		if (cacheKey !== undefined) {
-			digestCache.set(cacheKey, result);
+		if (digestCache !== undefined) {
+			digestCache.set(this.buffer, result);
 		}
 		return result;
 	}

package/lib/util/internalSerializables.js

@@ -150,6 +150,8 @@ module.exports = {
 		require("../dependencies/WebAssemblyExportImportedDependency"),
 	"dependencies/WebAssemblyImportDependency": () =>
 		require("../dependencies/WebAssemblyImportDependency"),
+	"dependencies/WebpackIsIncludedDependency": () =>
+		require("../dependencies/WebpackIsIncludedDependency"),
 	"dependencies/WorkerDependency": () =>
 		require("../dependencies/WorkerDependency"),
 	"optimize/ConcatenatedModule": () =>

package/lib/util/processAsyncTree.js

@@ -0,0 +1,61 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @template T
+ * @param {Iterable<T>} items initial items
+ * @param {number} concurrency number of items running in parallel
+ * @param {function(T, function(T): void, function(Error=): void): void} processor worker which pushes more items
+ * @param {function(Error=): void} callback all items processed
+ * @returns {void}
+ */
+const processAsyncTree = (items, concurrency, processor, callback) => {
+	const queue = Array.from(items);
+	if (queue.length === 0) return callback();
+	let processing = 0;
+	let finished = false;
+	let processScheduled = true;
+
+	const push = item => {
+		queue.push(item);
+		if (!processScheduled && processing < concurrency) {
+			processScheduled = true;
+			process.nextTick(processQueue);
+		}
+	};
+
+	const processorCallback = err => {
+		processing--;
+		if (err && !finished) {
+			finished = true;
+			callback(err);
+			return;
+		}
+		if (!processScheduled) {
+			processScheduled = true;
+			process.nextTick(processQueue);
+		}
+	};
+
+	const processQueue = () => {
+		if (finished) return;
+		while (processing < concurrency && queue.length > 0) {
+			processing++;
+			const item = queue.pop();
+			processor(item, push, processorCallback);
+		}
+		processScheduled = false;
+		if (queue.length === 0 && processing === 0 && !finished) {
+			finished = true;
+			callback();
+		}
+	};
+
+	processQueue();
+};
+
+module.exports = processAsyncTree;

package/lib/util/runtime.js

@@ -54,14 +54,16 @@ exports.getEntryRuntime = (compilation, name, options) => {
 /**
  * @param {RuntimeSpec} runtime runtime
  * @param {function(string): void} fn functor
+ * @param {boolean} deterministicOrder enforce a deterministic order
  * @returns {void}
  */
-exports.forEachRuntime = (runtime, fn) => {
+exports.forEachRuntime = (runtime, fn, deterministicOrder = false) => {
 	if (runtime === undefined) {
 		fn(undefined);
 	} else if (typeof runtime === "string") {
 		fn(runtime);
 	} else {
+		if (deterministicOrder) runtime.sort();
 		for (const r of runtime) {
 			fn(r);
 		}
@@ -448,6 +450,15 @@ class RuntimeSpecMap {
 		this._map.set(getRuntimeKey(runtime), value);
 	}
 
+	provide(runtime, computer) {
+		const key = getRuntimeKey(runtime);
+		const value = this._map.get(key);
+		if (value !== undefined) return value;
+		const newValue = computer();
+		this._map.set(key, newValue);
+		return newValue;
+	}
+
 	delete(runtime) {
 		this._map.delete(getRuntimeKey(runtime));
 	}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "webpack",
-  "version": "5.14.0",
+  "version": "5.18.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
   "dependencies": {
     "@types/eslint-scope": "^3.7.0",
-    "@types/estree": "^0.0.45",
+    "@types/estree": "^0.0.46",
     "@webassemblyjs/ast": "1.11.0",
     "@webassemblyjs/wasm-edit": "1.11.0",
     "@webassemblyjs/wasm-parser": "1.11.0",
@@ -49,7 +49,7 @@
     "core-js": "^3.6.5",
     "coveralls": "^3.1.0",
     "cspell": "^4.0.63",
-    "css-loader": "^3.6.0",
+    "css-loader": "^5.0.1",
     "date-fns": "^2.15.0",
     "es5-ext": "^0.10.53",
     "es6-promise-polyfill": "^1.2.0",