webpack 5.34.0 → 5.36.1

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/serialization/BinaryMiddleware.js

@@ -123,6 +123,12 @@ class BinaryMiddleware extends SerializerMiddleware {
 		return this._serialize(data, context);
 	}
 
+	_serializeLazy(fn, context) {
+		return SerializerMiddleware.serializeLazy(fn, data =>
+			this._serialize(data, context)
+		);
+	}
+
 	/**
 	 * @param {DeserializedType} data data
 	 * @param {Object} context context object
@@ -135,7 +141,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		let leftOverBuffer = null;
 		let currentPosition = 0;
 		/** @type {BufferSerializableType[]} */
-		const buffers = [];
+		let buffers = [];
 		let buffersTotalLength = 0;
 		const allocate = bytesNeeded => {
 			if (currentBuffer !== null) {
@@ -204,10 +210,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 								SerializerMiddleware.setLazySerializedValue(thing, data);
 								serializedData = data;
 							} else {
-								serializedData = SerializerMiddleware.serializeLazy(
-									thing,
-									data => this._serialize(data, context)
-								);
+								serializedData = this._serializeLazy(thing, context);
 							}
 						}
 						if (typeof serializedData === "function") {
@@ -474,7 +477,13 @@ class BinaryMiddleware extends SerializerMiddleware {
 		};
 		serializeData(data);
 		flush();
-		return buffers;
+
+		// avoid leaking memory
+		currentBuffer = null;
+		leftOverBuffer = null;
+		const _buffers = buffers;
+		buffers = undefined;
+		return _buffers;
 	}
 
 	/**
@@ -486,6 +495,21 @@ class BinaryMiddleware extends SerializerMiddleware {
 		return this._deserialize(data, context);
 	}
 
+	_createLazyDeserialized(content, context) {
+		return SerializerMiddleware.createLazy(
+			memoize(() => this._deserialize(content, context)),
+			this,
+			undefined,
+			content
+		);
+	}
+
+	_deserializeLazy(fn, context) {
+		return SerializerMiddleware.deserializeLazy(fn, data =>
+			this._deserialize(data, context)
+		);
+	}
+
 	/**
 	 * @param {SerializedType} data data
 	 * @param {Object} context context object
@@ -497,6 +521,8 @@ class BinaryMiddleware extends SerializerMiddleware {
 		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
 		let currentPosition = 0;
 
+		const retainedBuffer = context.retainedBuffer || (x => x);
+
 		const checkOverflow = () => {
 			if (currentPosition >= currentBuffer.length) {
 				currentPosition = 0;
@@ -610,23 +636,16 @@ class BinaryMiddleware extends SerializerMiddleware {
 								do {
 									const buf = readUpTo(l);
 									l -= buf.length;
-									content.push(buf);
+									content.push(retainedBuffer(buf));
 								} while (l > 0);
 							}
 						}
-						result.push(
-							SerializerMiddleware.createLazy(
-								memoize(() => this._deserialize(content, context)),
-								this,
-								undefined,
-								content
-							)
-						);
+						result.push(this._createLazyDeserialized(content, context));
 					};
 				case BUFFER_HEADER:
 					return () => {
 						const len = readU32();
-						result.push(read(len));
+						result.push(retainedBuffer(read(len)));
 					};
 				case TRUE_HEADER:
 					return () => result.push(true);
@@ -852,14 +871,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 		});
 
 		/** @type {DeserializedType} */
-		const result = [];
+		let result = [];
 		while (currentBuffer !== null) {
 			if (typeof currentBuffer === "function") {
-				result.push(
-					SerializerMiddleware.deserializeLazy(currentBuffer, data =>
-						this._deserialize(data, context)
-					)
-				);
+				result.push(this._deserializeLazy(currentBuffer, context));
 				currentDataItem++;
 				currentBuffer =
 					currentDataItem < data.length ? data[currentDataItem] : null;
@@ -869,7 +884,11 @@ class BinaryMiddleware extends SerializerMiddleware {
 				dispatchTable[header]();
 			}
 		}
-		return result;
+
+		// avoid leaking memory in context
+		let _result = result;
+		result = undefined;
+		return _result;
 	}
 }
 

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

@@ -34,9 +34,7 @@ const createCachedParameterizedComparator = fn => {
 		 * @param {T} b second item
 		 * @returns {-1|0|1} compare result
 		 */
-		const result = (a, b) => {
-			return fn(arg, a, b);
-		};
+		const result = fn.bind(null, arg);
 		map.set(arg, result);
 		return result;
 	};
@@ -435,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.34.0",
+  "version": "5.36.1",
   "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",
@@ -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",