webpack 5.35.1 → 5.37.0

package/lib/RuntimeGlobals.js

@@ -168,6 +168,13 @@ exports.scriptNonce = "__webpack_require__.nc";
  */
 exports.loadScript = "__webpack_require__.l";
 
+/**
+ * function to promote a string to a TrustedScriptURL using webpack's Trusted
+ * Types policy
+ * Arguments: (url: string) => TrustedScriptURL
+ */
+exports.createScriptUrl = "__webpack_require__.tu";
+
 /**
  * the chunk name of the chunk with the runtime
  */

package/lib/RuntimePlugin.js

@@ -13,6 +13,7 @@ const AutoPublicPathRuntimeModule = require("./runtime/AutoPublicPathRuntimeModu
 const CompatGetDefaultExportRuntimeModule = require("./runtime/CompatGetDefaultExportRuntimeModule");
 const CompatRuntimeModule = require("./runtime/CompatRuntimeModule");
 const CreateFakeNamespaceObjectRuntimeModule = require("./runtime/CreateFakeNamespaceObjectRuntimeModule");
+const CreateScriptUrlRuntimeModule = require("./runtime/CreateScriptUrlRuntimeModule");
 const DefinePropertyGettersRuntimeModule = require("./runtime/DefinePropertyGettersRuntimeModule");
 const EnsureChunkRuntimeModule = require("./runtime/EnsureChunkRuntimeModule");
 const GetChunkFilenameRuntimeModule = require("./runtime/GetChunkFilenameRuntimeModule");
@@ -38,6 +39,7 @@ const GLOBALS_ON_REQUIRE = [
 	RuntimeGlobals.runtimeId,
 	RuntimeGlobals.compatGetDefaultExport,
 	RuntimeGlobals.createFakeNamespaceObject,
+	RuntimeGlobals.createScriptUrl,
 	RuntimeGlobals.definePropertyGetters,
 	RuntimeGlobals.ensureChunk,
 	RuntimeGlobals.entryModuleId,
@@ -319,7 +321,23 @@ class RuntimePlugin {
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.loadScript)
 				.tap("RuntimePlugin", (chunk, set) => {
-					compilation.addRuntimeModule(chunk, new LoadScriptRuntimeModule());
+					const withCreateScriptUrl = !!compilation.outputOptions.trustedTypes;
+					if (withCreateScriptUrl) {
+						set.add(RuntimeGlobals.createScriptUrl);
+					}
+					compilation.addRuntimeModule(
+						chunk,
+						new LoadScriptRuntimeModule(withCreateScriptUrl)
+					);
+					return true;
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.createScriptUrl)
+				.tap("RuntimePlugin", (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new CreateScriptUrlRuntimeModule()
+					);
 					return true;
 				});
 			compilation.hooks.runtimeRequirementInTree

package/lib/SourceMapDevToolPlugin.js

@@ -16,7 +16,6 @@ const createHash = require("./util/createHash");
 const { relative, dirname } = require("./util/fs");
 const { absolutify } = require("./util/identifier");
 
-/** @typedef {import("source-map").RawSourceMap} SourceMap */
 /** @typedef {import("webpack-sources").MapOptions} MapOptions */
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/plugins/SourceMapDevToolPlugin").SourceMapDevToolPluginOptions} SourceMapDevToolPluginOptions */
@@ -26,6 +25,7 @@ const { absolutify } = require("./util/identifier");
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import("./NormalModule").SourceMap} SourceMap */
 /** @typedef {import("./util/Hash")} Hash */
 
 const validate = createSchemaValidation(

package/lib/WebpackOptionsApply.js

@@ -569,6 +569,7 @@ class WebpackOptionsApply extends OptionsApply {
 									),
 									snapshot: options.snapshot,
 									maxAge: cacheOptions.maxAge,
+									profile: cacheOptions.profile,
 									allowCollectingMemory: cacheOptions.allowCollectingMemory
 								}),
 								cacheOptions.idleTimeout,

package/lib/buildChunkGraph.js

@@ -997,10 +997,15 @@ const visitModules = (
 	};
 
 	const processChunkGroupsForCombining = () => {
-		loop: for (const info of chunkGroupsForCombining) {
+		for (const info of chunkGroupsForCombining) {
 			for (const source of info.availableSources) {
-				if (!source.minAvailableModules) continue loop;
+				if (!source.minAvailableModules) {
+					chunkGroupsForCombining.delete(info);
+					break;
+				}
 			}
+		}
+		for (const info of chunkGroupsForCombining) {
 			const availableModules = /** @type {ModuleSetPlus} */ (new Set());
 			availableModules.plus = EMPTY_SET;
 			const mergeSet = set => {

package/lib/cache/PackFileCacheStrategy.js

@@ -561,7 +561,40 @@ class PackContentItems {
 		this.map = map;
 	}
 
-	serialize({ write, snapshot, rollback, logger }) {
+	serialize({ write, snapshot, rollback, logger, profile }) {
+		if (profile) {
+			write(false);
+			for (const [key, value] of this.map) {
+				const s = snapshot();
+				try {
+					write(key);
+					const start = process.hrtime();
+					write(value);
+					const durationHr = process.hrtime(start);
+					const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+					if (duration > 1) {
+						if (duration > 500)
+							logger.error(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 50)
+							logger.warn(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 10)
+							logger.info(`Serialization of '${key}': ${duration} ms`);
+						else if (duration > 5)
+							logger.log(`Serialization of '${key}': ${duration} ms`);
+						else logger.debug(`Serialization of '${key}': ${duration} ms`);
+					}
+				} catch (e) {
+					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
+					logger.warn(
+						`Skipped not serializable cache item '${key}': ${e.message}`
+					);
+					logger.debug(e.stack);
+				}
+			}
+			write(null);
+			return;
+		}
 		// Try to serialize all at once
 		const s = snapshot();
 		try {
@@ -590,9 +623,32 @@ class PackContentItems {
 		}
 	}
 
-	deserialize({ read }) {
+	deserialize({ read, logger, profile }) {
 		if (read()) {
 			this.map = read();
+		} else if (profile) {
+			const map = new Map();
+			let key = read();
+			while (key !== null) {
+				const start = process.hrtime();
+				const value = read();
+				const durationHr = process.hrtime(start);
+				const duration = durationHr[0] * 1000 + durationHr[1] / 1e6;
+				if (duration > 1) {
+					if (duration > 100)
+						logger.error(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 20)
+						logger.warn(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 5)
+						logger.info(`Deserialization of '${key}': ${duration} ms`);
+					else if (duration > 2)
+						logger.log(`Deserialization of '${key}': ${duration} ms`);
+					else logger.debug(`Deserialization of '${key}': ${duration} ms`);
+				}
+				map.set(key, value);
+				key = read();
+			}
+			this.map = map;
 		} else {
 			const map = new Map();
 			let key = read();
@@ -787,6 +843,7 @@ class PackFileCacheStrategy {
 	 * @param {Logger} options.logger a logger
 	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
 	 * @param {number} options.maxAge max age of cache items
+	 * @param {boolean} options.profile track and log detailed timing information for individual cache items
 	 * @param {boolean} options.allowCollectingMemory allow to collect unused memory created during deserialization
 	 */
 	constructor({
@@ -798,6 +855,7 @@ class PackFileCacheStrategy {
 		logger,
 		snapshot,
 		maxAge,
+		profile,
 		allowCollectingMemory
 	}) {
 		this.fileSerializer = createFileSerializer(fs);
@@ -812,6 +870,7 @@ class PackFileCacheStrategy {
 		this.version = version;
 		this.logger = logger;
 		this.maxAge = maxAge;
+		this.profile = profile;
 		this.allowCollectingMemory = allowCollectingMemory;
 		this.snapshot = snapshot;
 		/** @type {Set<string>} */
@@ -840,7 +899,7 @@ class PackFileCacheStrategy {
 	 * @returns {Promise<Pack>} the pack
 	 */
 	_openPack() {
-		const { logger, cacheLocation, version } = this;
+		const { logger, profile, cacheLocation, version } = this;
 		/** @type {Snapshot} */
 		let buildSnapshot;
 		/** @type {Set<string>} */
@@ -857,6 +916,7 @@ class PackFileCacheStrategy {
 				filename: `${cacheLocation}/index.pack`,
 				extension: ".pack",
 				logger,
+				profile,
 				retainedBuffer: this.allowCollectingMemory
 					? allowCollectingMemory
 					: undefined
@@ -1172,7 +1232,8 @@ class PackFileCacheStrategy {
 						.serialize(content, {
 							filename: `${this.cacheLocation}/index.pack`,
 							extension: ".pack",
-							logger: this.logger
+							logger: this.logger,
+							profile: this.profile
 						})
 						.then(() => {
 							for (const dep of newBuildDependencies) {

package/lib/config/defaults.js

@@ -293,6 +293,7 @@ const applyCacheDefaults = (cache, { name, mode, development }) => {
 			);
 			D(cache, "hashAlgorithm", "md4");
 			D(cache, "store", "pack");
+			D(cache, "profile", false);
 			D(cache, "idleTimeout", 60000);
 			D(cache, "idleTimeoutForInitialStore", 0);
 			D(cache, "maxMemoryGenerations", development ? 5 : Infinity);
@@ -731,6 +732,16 @@ const applyOutputDefaults = (
 	F(output.environment, "dynamicImport", () => tp && tp.dynamicImport);
 	F(output.environment, "module", () => tp && tp.module);
 
+	const { trustedTypes } = output;
+	if (trustedTypes) {
+		F(
+			trustedTypes,
+			"policyName",
+			() =>
+				output.uniqueName.replace(/[^a-zA-Z0-9\-#=_/@.%]+/g, "_") || "webpack"
+		);
+	}
+
 	/**
 	 * @param {function(EntryDescription): void} fn iterator
 	 * @returns {void}
@@ -948,7 +959,7 @@ const applyOptimizationDefaults = (
 		A(splitChunks, "defaultSizeTypes", () => ["javascript", "unknown"]);
 		D(splitChunks, "hidePathInfo", production);
 		D(splitChunks, "chunks", "async");
-		D(splitChunks, "usedExports", true);
+		D(splitChunks, "usedExports", optimization.usedExports === true);
 		D(splitChunks, "minChunks", 1);
 		F(splitChunks, "minSize", () => (production ? 20000 : 10000));
 		F(splitChunks, "minRemainingSize", () => (development ? 0 : undefined));

package/lib/config/normalization.js

@@ -131,6 +131,7 @@ const getNormalizedWebpackOptions = config => {
 						type: "filesystem",
 						maxMemoryGenerations: cache.maxMemoryGenerations,
 						maxAge: cache.maxAge,
+						profile: cache.profile,
 						buildDependencies: cloneObject(cache.buildDependencies),
 						cacheDirectory: cache.cacheDirectory,
 						cacheLocation: cache.cacheLocation,
@@ -337,6 +338,15 @@ const getNormalizedWebpackOptions = config => {
 				sourceMapFilename: output.sourceMapFilename,
 				sourcePrefix: output.sourcePrefix,
 				strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+				trustedTypes: optionalNestedConfig(
+					output.trustedTypes,
+					trustedTypes => {
+						if (trustedTypes === true) return {};
+						if (typeof trustedTypes === "string")
+							return { policyName: trustedTypes };
+						return { ...trustedTypes };
+					}
+				),
 				uniqueName: output.uniqueName,
 				wasmLoading: output.wasmLoading,
 				webassemblyModuleFilename: output.webassemblyModuleFilename,

package/lib/dependencies/CreateScriptUrlDependency.js

@@ -0,0 +1,54 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const makeSerializable = require("../util/makeSerializable");
+const NullDependency = require("./NullDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+
+class CreateScriptUrlDependency extends NullDependency {
+	/**
+	 * @param {[number, number]} range range
+	 */
+	constructor(range) {
+		super();
+		this.range = range;
+	}
+
+	get type() {
+		return "create script url";
+	}
+}
+
+CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (
+	NullDependency.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, { runtimeRequirements }) {
+		const dep = /** @type {CreateScriptUrlDependency} */ (dependency);
+
+		runtimeRequirements.add(RuntimeGlobals.createScriptUrl);
+
+		source.insert(dep.range[0], `${RuntimeGlobals.createScriptUrl}(`);
+		source.insert(dep.range[1], ")");
+	}
+};
+
+makeSerializable(
+	CreateScriptUrlDependency,
+	"webpack/lib/dependencies/CreateScriptUrlDependency"
+);
+
+module.exports = CreateScriptUrlDependency;

package/lib/dependencies/HarmonyExportInitFragment.js

@@ -48,6 +48,53 @@ class HarmonyExportInitFragment extends InitFragment {
 		this.unusedExports = unusedExports;
 	}
 
+	/**
+	 * @param {HarmonyExportInitFragment[]} fragments all fragments to merge
+	 * @returns {HarmonyExportInitFragment} merged fragment
+	 */
+	mergeAll(fragments) {
+		let exportMap;
+		let exportMapOwned = false;
+		let unusedExports;
+		let unusedExportsOwned = false;
+
+		for (const fragment of fragments) {
+			if (fragment.exportMap.size !== 0) {
+				if (exportMap === undefined) {
+					exportMap = fragment.exportMap;
+					exportMapOwned = false;
+				} else {
+					if (!exportMapOwned) {
+						exportMap = new Map(exportMap);
+						exportMapOwned = true;
+					}
+					for (const [key, value] of fragment.exportMap) {
+						if (!exportMap.has(key)) exportMap.set(key, value);
+					}
+				}
+			}
+			if (fragment.unusedExports.size !== 0) {
+				if (unusedExports === undefined) {
+					unusedExports = fragment.unusedExports;
+					unusedExportsOwned = false;
+				} else {
+					if (!unusedExportsOwned) {
+						unusedExports = new Set(unusedExports);
+						unusedExportsOwned = true;
+					}
+					for (const value of fragment.unusedExports) {
+						unusedExports.add(value);
+					}
+				}
+			}
+		}
+		return new HarmonyExportInitFragment(
+			this.exportsArgument,
+			exportMap,
+			unusedExports
+		);
+	}
+
 	merge(other) {
 		let exportMap;
 		if (this.exportMap.size === 0) {

package/lib/dependencies/NullDependency.js

@@ -19,14 +19,6 @@ class NullDependency extends Dependency {
 	get type() {
 		return "null";
 	}
-
-	serialize({ write }) {
-		write(this.loc);
-	}
-
-	deserialize({ read }) {
-		this.loc = read();
-	}
 }
 
 NullDependency.Template = class NullDependencyTemplate extends (

package/lib/dependencies/WorkerPlugin.js

@@ -9,12 +9,13 @@ const { pathToFileURL } = require("url");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const CommentCompilationWarning = require("../CommentCompilationWarning");
 const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
-const formatLocation = require("../formatLocation");
 const EnableChunkLoadingPlugin = require("../javascript/EnableChunkLoadingPlugin");
 const { equals } = require("../util/ArrayHelpers");
+const createHash = require("../util/createHash");
 const { contextify } = require("../util/identifier");
 const EnableWasmLoadingPlugin = require("../wasm/EnableWasmLoadingPlugin");
 const ConstDependency = require("./ConstDependency");
+const CreateScriptUrlDependency = require("./CreateScriptUrlDependency");
 const {
 	harmonySpecifierTag
 } = require("./HarmonyImportDependencyParserPlugin");
@@ -27,6 +28,7 @@ const WorkerDependency = require("./WorkerDependency");
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+/** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../javascript/BasicEvaluatedExpression")} BasicEvaluatedExpression */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("./HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
@@ -42,6 +44,9 @@ const DEFAULT_SYNTAX = [
 	"Worker from worker_threads"
 ];
 
+/** @type {WeakMap<ParserState, number>} */
+const workerIndexMap = new WeakMap();
+
 class WorkerPlugin {
 	constructor(chunkLoading, wasmLoading) {
 		this._chunkLoading = chunkLoading;
@@ -74,6 +79,10 @@ class WorkerPlugin {
 					WorkerDependency,
 					new WorkerDependency.Template()
 				);
+				compilation.dependencyTemplates.set(
+					CreateScriptUrlDependency,
+					new CreateScriptUrlDependency.Template()
+				);
 
 				/**
 				 * @param {JavascriptParser} parser the parser
@@ -264,9 +273,20 @@ class WorkerPlugin {
 						}
 
 						if (!entryOptions.runtime) {
-							entryOptions.runtime = `${cachedContextify(
+							let i = workerIndexMap.get(parser.state) || 0;
+							workerIndexMap.set(parser.state, i + 1);
+							let name = `${cachedContextify(
 								parser.state.module.identifier()
-							)}|${formatLocation(expr.loc)}`;
+							)}|${i}`;
+							const hash = createHash(compilation.outputOptions.hashFunction);
+							hash.update(name);
+							const digest = /** @type {string} */ (hash.digest(
+								compilation.outputOptions.hashDigest
+							));
+							entryOptions.runtime = digest.slice(
+								0,
+								compilation.outputOptions.hashDigestLength
+							);
 						}
 
 						const block = new AsyncDependenciesBlock({
@@ -282,7 +302,14 @@ class WorkerPlugin {
 						dep.loc = expr.loc;
 						block.addDependency(dep);
 						parser.state.module.addBlock(block);
-						parser.walkExpression(expr.callee);
+
+						if (compilation.outputOptions.trustedTypes) {
+							const dep = new CreateScriptUrlDependency(
+								expr.arguments[0].range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+						}
 
 						if (expressions.type) {
 							const expr = expressions.type;
@@ -314,6 +341,7 @@ class WorkerPlugin {
 							parser.state.module.addPresentationalDependency(dep2);
 						}
 
+						parser.walkExpression(expr.callee);
 						for (const key of Object.keys(expressions)) {
 							if (expressions[key]) parser.walkExpression(expressions[key]);
 						}

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/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);