webpack 5.35.0 → 5.36.2

package/lib/javascript/JavascriptParser.js

@@ -161,7 +161,7 @@ class JavascriptParser extends Parser {
 			evaluateCallExpressionMember: new HookMap(
 				() => new SyncBailHook(["expression", "param"])
 			),
-			/** @type {HookMap<SyncBailHook<[ExpressionNode | DeclarationNode, number], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[ExpressionNode | DeclarationNode | PrivateIdentifierNode, number], boolean | void>>} */
 			isPure: new HookMap(
 				() => new SyncBailHook(["expression", "commentsStartPosition"])
 			),
@@ -176,8 +176,10 @@ class JavascriptParser extends Parser {
 			statementIf: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[ExpressionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
 			classExtendsExpression: new SyncBailHook(["expression", "statement"]),
-			/** @type {SyncBailHook<[MethodDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			/** @type {SyncBailHook<[MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
 			classBodyElement: new SyncBailHook(["element", "statement"]),
+			/** @type {SyncBailHook<[ExpressionNode, MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classBodyValue: new SyncBailHook(["expression", "element", "statement"]),
 			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
 			label: new HookMap(() => new SyncBailHook(["statement"])),
 			/** @type {SyncBailHook<[StatementNode, ImportSource], boolean | void>} */
@@ -1363,29 +1365,30 @@ class JavascriptParser extends Parser {
 			}
 		}
 		if (classy.body && classy.body.type === "ClassBody") {
-			const wasTopLevel = this.scope.topLevelScope;
-			for (const classElement of classy.body.body) {
+			for (const classElement of /** @type {TODO} */ (classy.body.body)) {
 				if (!this.hooks.classBodyElement.call(classElement, classy)) {
-					if (classElement.type === "MethodDefinition") {
-						this.scope.topLevelScope = false;
-						this.walkMethodDefinition(classElement);
-						this.scope.topLevelScope = wasTopLevel;
+					if (classElement.computed && classElement.key) {
+						this.walkExpression(classElement.key);
+					}
+					if (classElement.value) {
+						if (
+							!this.hooks.classBodyValue.call(
+								classElement.value,
+								classElement,
+								classy
+							)
+						) {
+							const wasTopLevel = this.scope.topLevelScope;
+							this.scope.topLevelScope = false;
+							this.walkExpression(classElement.value);
+							this.scope.topLevelScope = wasTopLevel;
+						}
 					}
-					// TODO add support for ClassProperty here once acorn supports it
 				}
 			}
 		}
 	}
 
-	walkMethodDefinition(methodDefinition) {
-		if (methodDefinition.computed && methodDefinition.key) {
-			this.walkExpression(methodDefinition.key);
-		}
-		if (methodDefinition.value) {
-			this.walkExpression(methodDefinition.value);
-		}
-	}
-
 	// Pre walking iterates the scope for variable declarations
 	preWalkStatements(statements) {
 		for (let index = 0, len = statements.length; index < len; index++) {
@@ -3316,7 +3319,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {ExpressionNode | DeclarationNode | null | undefined} expr an expression
+	 * @param {ExpressionNode | DeclarationNode | PrivateIdentifierNode | null | undefined} expr an expression
 	 * @param {number} commentsStartPos source position from which annotation comments are checked
 	 * @returns {boolean} true, when the expression is pure
 	 */
@@ -3328,27 +3331,32 @@ class JavascriptParser extends Parser {
 		if (typeof result === "boolean") return result;
 		switch (expr.type) {
 			case "ClassDeclaration":
-			case "ClassExpression":
+			case "ClassExpression": {
 				if (expr.body.type !== "ClassBody") return false;
 				if (expr.superClass && !this.isPure(expr.superClass, expr.range[0])) {
 					return false;
 				}
-				return expr.body.body.every(item => {
-					switch (item.type) {
-						// @ts-expect-error not yet supported by acorn
-						case "ClassProperty":
-							// TODO add test case once acorn supports it
-							// Currently this is not parsable
-							if (item.static) return this.isPure(item.value, item.range[0]);
-							break;
-					}
-					return true;
-				});
+				const items = /** @type {(MethodDefinitionNode | PropertyDefinitionNode)[]} */ (expr
+					.body.body);
+				return items.every(
+					item =>
+						(!item.computed ||
+							!item.key ||
+							this.isPure(item.key, item.range[0])) &&
+						(!item.static ||
+							!item.value ||
+							this.isPure(
+								item.value,
+								item.key ? item.key.range[1] : item.range[0]
+							))
+				);
+			}
 
 			case "FunctionDeclaration":
 			case "FunctionExpression":
 			case "ArrowFunctionExpression":
 			case "Literal":
+			case "PrivateIdentifier":
 				return true;
 
 			case "VariableDeclaration":

package/lib/library/AmdLibraryPlugin.js

@@ -107,7 +107,8 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 		const fnStart =
 			(modern
 				? `(${externalsArguments}) => {`
-				: `function(${externalsArguments}) {`) + (iife ? " return " : "\n");
+				: `function(${externalsArguments}) {`) +
+			(iife || !chunk.hasRuntime() ? " return " : "\n");
 		const fnEnd = iife ? ";\n}" : "\n}";
 
 		if (this.requireAsWrapper) {

package/lib/optimize/InnerGraphPlugin.js

@@ -238,21 +238,20 @@ class InnerGraphPlugin {
 						}
 					);
 
-					parser.hooks.classBodyElement.tap(
+					parser.hooks.classBodyValue.tap(
 						"InnerGraphPlugin",
-						(element, statement) => {
+						(expression, element, statement) => {
 							if (!InnerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
 								const fn = classWithTopLevelSymbol.get(statement);
 								if (fn) {
-									if (element.type === "MethodDefinition") {
-										InnerGraph.setTopLevelSymbol(parser.state, fn);
-									} else if (
-										element.type === "ClassProperty" &&
-										!element.static
+									if (
+										!element.static ||
+										parser.isPure(
+											expression,
+											element.key ? element.key.range[1] : element.range[0]
+										)
 									) {
-										// TODO add test case once acorn supports it
-										// Currently this is not parsable
 										InnerGraph.setTopLevelSymbol(parser.state, fn);
 									} else {
 										InnerGraph.setTopLevelSymbol(parser.state, undefined);

package/lib/util/AsyncQueue.js

@@ -119,7 +119,12 @@ class AsyncQueue {
 			const entry = this._entries.get(key);
 			if (entry !== undefined) {
 				if (entry.state === DONE_STATE) {
-					process.nextTick(() => callback(entry.error, entry.result));
+					if (inHandleResult++ > 3) {
+						process.nextTick(() => callback(entry.error, entry.result));
+					} else {
+						callback(entry.error, entry.result);
+					}
+					inHandleResult--;
 				} else if (entry.callbacks === undefined) {
 					entry.callbacks = [callback];
 				} else {

package/lib/util/comparators.js

@@ -433,21 +433,27 @@ exports.compareLocations = (a, b) => {
 		if (isObjectB) return -1;
 		return 0;
 	}
-	if ("start" in a && "start" in b) {
-		const ap = a.start;
-		const bp = b.start;
-		if (ap.line < bp.line) return -1;
-		if (ap.line > bp.line) return 1;
-		if (ap.column < bp.column) return -1;
-		if (ap.column > bp.column) return 1;
-	}
-	if ("name" in a && "name" in b) {
-		if (a.name < b.name) return -1;
-		if (a.name > b.name) return 1;
-	}
-	if ("index" in a && "index" in b) {
-		if (a.index < b.index) return -1;
-		if (a.index > b.index) return 1;
-	}
+	if ("start" in a) {
+		if ("start" in b) {
+			const ap = a.start;
+			const bp = b.start;
+			if (ap.line < bp.line) return -1;
+			if (ap.line > bp.line) return 1;
+			if (ap.column < bp.column) return -1;
+			if (ap.column > bp.column) return 1;
+		} else return -1;
+	} else if ("start" in b) return 1;
+	if ("name" in a) {
+		if ("name" in b) {
+			if (a.name < b.name) return -1;
+			if (a.name > b.name) return 1;
+		} else return -1;
+	} else if ("name" in b) return 1;
+	if ("index" in a) {
+		if ("index" in b) {
+			if (a.index < b.index) return -1;
+			if (a.index > b.index) return 1;
+		} else return -1;
+	} else if ("index" in b) return 1;
 	return 0;
 };

package/lib/util/smartGrouping.js

@@ -23,9 +23,16 @@
 
 /**
  * @template T
+ * @template R
  * @typedef {Object} ItemWithGroups
  * @property {T} item
- * @property {Set<string>} groups
+ * @property {Set<Group<T, R>>} groups
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {{ config: GroupConfig<T, R>, name: string, alreadyGrouped: boolean, items: Set<ItemWithGroups<T, R>> | undefined }} Group
  */
 
 /**
@@ -36,22 +43,32 @@
  * @returns {(R | T)[]} grouped items
  */
 const smartGrouping = (items, groupConfigs) => {
-	/** @type {Set<ItemWithGroups<T>>} */
+	/** @type {Set<ItemWithGroups<T, R>>} */
 	const itemsWithGroups = new Set();
-	/** @type {Map<string, [GroupConfig<T, R>, string]>} */
-	const groupConfigMap = new Map();
+	/** @type {Map<string, Group<T, R>>} */
+	const allGroups = new Map();
 	for (const item of items) {
+		/** @type {Set<Group<T, R>>} */
 		const groups = new Set();
 		for (let i = 0; i < groupConfigs.length; i++) {
 			const groupConfig = groupConfigs[i];
 			const keys = groupConfig.getKeys(item);
 			if (keys) {
-				for (const group of keys) {
-					const fullGroup = `${i}:${group}`;
-					if (!groupConfigMap.has(fullGroup)) {
-						groupConfigMap.set(fullGroup, [groupConfig, group]);
+				for (const name of keys) {
+					const key = `${i}:${name}`;
+					let group = allGroups.get(key);
+					if (group === undefined) {
+						allGroups.set(
+							key,
+							(group = {
+								config: groupConfig,
+								name,
+								alreadyGrouped: false,
+								items: undefined
+							})
+						);
 					}
-					groups.add(fullGroup);
+					groups.add(group);
 				}
 			}
 		}
@@ -60,48 +77,62 @@ const smartGrouping = (items, groupConfigs) => {
 			groups
 		});
 	}
-	const alreadyGrouped = new Set();
 	/**
-	 * @param {Set<ItemWithGroups<T>>} itemsWithGroups input items with groups
+	 * @param {Set<ItemWithGroups<T, R>>} itemsWithGroups input items with groups
 	 * @returns {(T | R)[]} groups items
 	 */
 	const runGrouping = itemsWithGroups => {
 		const totalSize = itemsWithGroups.size;
-		/** @type {Map<string, Set<ItemWithGroups<T>>>} */
-		const groupMap = new Map();
 		for (const entry of itemsWithGroups) {
 			for (const group of entry.groups) {
-				if (alreadyGrouped.has(group)) continue;
-				const list = groupMap.get(group);
-				if (list === undefined) {
-					groupMap.set(group, new Set([entry]));
+				if (group.alreadyGrouped) continue;
+				const items = group.items;
+				if (items === undefined) {
+					group.items = new Set([entry]);
 				} else {
-					list.add(entry);
+					items.add(entry);
 				}
 			}
 		}
-		/** @type {Set<string>} */
-		const usedGroups = new Set();
+		/** @type {Map<Group<T, R>, { items: Set<ItemWithGroups<T, R>>, options: GroupOptions | false | undefined, used: boolean }>} */
+		const groupMap = new Map();
+		for (const group of allGroups.values()) {
+			if (group.items) {
+				const items = group.items;
+				group.items = undefined;
+				groupMap.set(group, {
+					items,
+					options: undefined,
+					used: false
+				});
+			}
+		}
 		/** @type {(T | R)[]} */
 		const results = [];
 		for (;;) {
+			/** @type {Group<T, R>} */
 			let bestGroup = undefined;
 			let bestGroupSize = -1;
 			let bestGroupItems = undefined;
 			let bestGroupOptions = undefined;
-			for (const [group, items] of groupMap) {
-				if (items.size === 0) continue;
-				const [groupConfig, groupKey] = groupConfigMap.get(group);
-				const options =
-					groupConfig.getOptions &&
-					groupConfig.getOptions(
-						groupKey,
-						Array.from(items, ({ item }) => item)
-					);
+			for (const [group, state] of groupMap) {
+				const { items, used } = state;
+				let options = state.options;
+				if (options === undefined) {
+					const groupConfig = group.config;
+					state.options = options =
+						(groupConfig.getOptions &&
+							groupConfig.getOptions(
+								group.name,
+								Array.from(items, ({ item }) => item)
+							)) ||
+						false;
+				}
+
 				const force = options && options.force;
 				if (!force) {
 					if (bestGroupOptions && bestGroupOptions.force) continue;
-					if (usedGroups.has(group)) continue;
+					if (used) continue;
 					if (items.size <= 1 || totalSize - items.size <= 1) {
 						continue;
 					}
@@ -137,25 +168,30 @@ const smartGrouping = (items, groupConfigs) => {
 				itemsWithGroups.delete(item);
 				// Remove all groups that items have from the map to not select them again
 				for (const group of item.groups) {
-					const list = groupMap.get(group);
-					if (list !== undefined) list.delete(item);
-					if (groupChildren) {
-						usedGroups.add(group);
+					const state = groupMap.get(group);
+					if (state !== undefined) {
+						state.items.delete(item);
+						if (state.items.size === 0) {
+							groupMap.delete(group);
+						} else {
+							state.options = undefined;
+							if (groupChildren) {
+								state.used = true;
+							}
+						}
 					}
 				}
 			}
 			groupMap.delete(bestGroup);
 
-			const idx = bestGroup.indexOf(":");
-			const configKey = bestGroup.slice(0, idx);
-			const key = bestGroup.slice(idx + 1);
-			const groupConfig = groupConfigs[+configKey];
+			const key = bestGroup.name;
+			const groupConfig = bestGroup.config;
 
 			const allItems = Array.from(items, ({ item }) => item);
 
-			alreadyGrouped.add(bestGroup);
+			bestGroup.alreadyGrouped = true;
 			const children = groupChildren ? runGrouping(items) : allItems;
-			alreadyGrouped.delete(bestGroup);
+			bestGroup.alreadyGrouped = false;
 
 			results.push(groupConfig.createGroup(key, children, allItems));
 		}

package/lib/web/JsonpChunkLoadingRuntimeModule.js

@@ -400,7 +400,7 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 									"}"
 								]),
 								"}",
-								"if(runtime) runtime(__webpack_require__);",
+								"if(runtime) var result = runtime(__webpack_require__);",
 								"if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);",
 								"for(;i < chunkIds.length; i++) {",
 								Template.indent([
@@ -411,7 +411,9 @@ class JsonpChunkLoadingRuntimeModule extends RuntimeModule {
 									"installedChunks[chunkIds[i]] = 0;"
 								]),
 								"}",
-								withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+								withOnChunkLoad
+									? `return ${RuntimeGlobals.onChunksLoaded}(result);`
+									: ""
 							]
 						)}`,
 						"",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.35.0",
+  "version": "5.36.2",
   "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",
@@ -10,7 +10,7 @@
     "@webassemblyjs/ast": "1.11.0",
     "@webassemblyjs/wasm-edit": "1.11.0",
     "@webassemblyjs/wasm-parser": "1.11.0",
-    "acorn": "^8.0.4",
+    "acorn": "^8.2.1",
     "browserslist": "^4.14.5",
     "chrome-trace-event": "^1.0.2",
     "enhanced-resolve": "^5.8.0",
@@ -39,7 +39,7 @@
     "@babel/preset-react": "^7.10.4",
     "@types/es-module-lexer": "^0.3.0",
     "@types/jest": "^26.0.15",
-    "@types/node": "^14.14.10",
+    "@types/node": "^15.0.1",
     "babel-loader": "^8.1.0",
     "benchmark": "^2.1.4",
     "bundle-loader": "^0.5.6",
@@ -55,7 +55,7 @@
     "eslint": "^7.14.0",
     "eslint-config-prettier": "^8.1.0",
     "eslint-plugin-jest": "^24.1.3",
-    "eslint-plugin-jsdoc": "^32.0.2",
+    "eslint-plugin-jsdoc": "^33.0.0",
     "eslint-plugin-node": "^11.0.0",
     "eslint-plugin-prettier": "^3.1.4",
     "file-loader": "^6.0.0",
@@ -92,7 +92,7 @@
     "style-loader": "^2.0.0",
     "terser": "^5.5.0",
     "toml": "^3.0.0",
-    "tooling": "webpack/tooling#v1.17.0",
+    "tooling": "webpack/tooling#v1.18.0",
     "ts-loader": "^8.0.2",
     "typescript": "^4.2.0-beta",
     "url-loader": "^4.1.0",