webpack 5.39.0 → 5.41.1

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -0,0 +1,208 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const { SyncWaterfallHook } = require("tapable");
+const Compilation = require("../Compilation");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+const {
+	getChunkFilenameTemplate,
+	chunkHasJs
+} = require("../javascript/JavascriptModulesPlugin");
+const { getInitialChunkIds } = require("../javascript/StartupHelpers");
+const compileBooleanMatcher = require("../util/compileBooleanMatcher");
+const { getUndoPath } = require("../util/identifier");
+
+/** @typedef {import("../Chunk")} Chunk */
+
+/**
+ * @typedef {Object} JsonpCompilationPluginHooks
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
+ * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
+ */
+
+/** @type {WeakMap<Compilation, JsonpCompilationPluginHooks>} */
+const compilationHooksMap = new WeakMap();
+
+class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {JsonpCompilationPluginHooks} hooks
+	 */
+	static getCompilationHooks(compilation) {
+		if (!(compilation instanceof Compilation)) {
+			throw new TypeError(
+				"The 'compilation' argument must be an instance of Compilation"
+			);
+		}
+		let hooks = compilationHooksMap.get(compilation);
+		if (hooks === undefined) {
+			hooks = {
+				linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+				linkPrefetch: new SyncWaterfallHook(["source", "chunk"])
+			};
+			compilationHooksMap.set(compilation, hooks);
+		}
+		return hooks;
+	}
+
+	constructor(runtimeRequirements) {
+		super("import chunk loading", RuntimeModule.STAGE_ATTACH);
+		this._runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation, chunk } = this;
+		const {
+			runtimeTemplate,
+			chunkGraph,
+			outputOptions: { importFunctionName, importMetaName }
+		} = compilation;
+		const fn = RuntimeGlobals.ensureChunkHandlers;
+		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withLoading = this._runtimeRequirements.has(
+			RuntimeGlobals.ensureChunkHandlers
+		);
+		const withOnChunkLoad = this._runtimeRequirements.has(
+			RuntimeGlobals.onChunksLoaded
+		);
+		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
+		const hasJsMatcher = compileBooleanMatcher(conditionMap);
+		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph);
+
+		const outputName = this.compilation.getPath(
+			getChunkFilenameTemplate(chunk, this.compilation.outputOptions),
+			{
+				chunk,
+				contentHashType: "javascript"
+			}
+		);
+		const rootOutputDir = getUndoPath(
+			outputName,
+			this.compilation.outputOptions.path,
+			true
+		);
+
+		return Template.asString([
+			withBaseURI
+				? Template.asString([
+						`${RuntimeGlobals.baseURI} = new URL(${JSON.stringify(
+							rootOutputDir
+						)}, ${importMetaName}.url);`
+				  ])
+				: "// no baseURI",
+			"",
+			"// object to store loaded and loading chunks",
+			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			"var installedChunks = {",
+			Template.indent(
+				Array.from(initialChunkIds, id => `${JSON.stringify(id)}: 0`).join(
+					",\n"
+				)
+			),
+			"};",
+			"",
+			withLoading
+				? Template.asString([
+						`${fn}.j = ${runtimeTemplate.basicFunction(
+							"chunkId, promises",
+							hasJsMatcher !== false
+								? Template.indent([
+										"// import() chunk loading for javascript",
+										`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[1]);"
+											]),
+											"} else {",
+											Template.indent([
+												hasJsMatcher === true
+													? "if(true) { // all chunks have JS"
+													: `if(${hasJsMatcher("chunkId")}) {`,
+												Template.indent([
+													"// setup Promise in chunk cache",
+													`var promise = ${importFunctionName}(${JSON.stringify(
+														rootOutputDir
+													)} + ${
+														RuntimeGlobals.getChunkScriptFilename
+													}(chunkId)).then(${runtimeTemplate.basicFunction(
+														"data",
+														[
+															runtimeTemplate.destructureObject(
+																["ids", "modules", "runtime"],
+																"data"
+															),
+															'// add "modules" to the modules object,',
+															'// then flag all "ids" as loaded and fire callback',
+															"var moduleId, chunkId, i = 0;",
+															"for(moduleId in modules) {",
+															Template.indent([
+																`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
+																Template.indent(
+																	`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
+																),
+																"}"
+															]),
+															"}",
+															"if(runtime) runtime(__webpack_require__);",
+															"for(;i < ids.length; i++) {",
+															Template.indent([
+																"chunkId = ids[i];",
+																`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+																Template.indent(
+																	"installedChunks[chunkId][0]();"
+																),
+																"}",
+																"installedChunks[ids[i]] = 0;"
+															]),
+															"}",
+															withOnChunkLoad
+																? `${RuntimeGlobals.onChunksLoaded}();`
+																: ""
+														]
+													)}, ${runtimeTemplate.basicFunction("e", [
+														"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
+														"throw e;"
+													])});`,
+													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
+														`installedChunkData = installedChunks[chunkId] = [resolve]`,
+														"resolve"
+													)})])`,
+													`promises.push(installedChunkData[1] = promise);`
+												]),
+												"} else installedChunks[chunkId] = 0;"
+											]),
+											"}"
+										]),
+										"}"
+								  ])
+								: Template.indent(["installedChunks[chunkId] = 0;"])
+						)};`
+				  ])
+				: "// no chunk on demand loading",
+			"",
+			withOnChunkLoad
+				? `${
+						RuntimeGlobals.onChunksLoaded
+				  }.j = ${runtimeTemplate.returningFunction(
+						"installedChunks[chunkId] === 0",
+						"chunkId"
+				  )};`
+				: "// no on chunks loaded"
+		]);
+	}
+}
+
+module.exports = ModuleChunkLoadingRuntimeModule;

package/lib/hmr/lazyCompilationBackend.js

@@ -52,6 +52,16 @@ module.exports = (compiler, client, callback) => {
 		}
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
 	});
+	let isClosing = false;
+	/** @type {Set<import("net").Socket>} */
+	const sockets = new Set();
+	server.on("connection", socket => {
+		sockets.add(socket);
+		socket.on("close", () => {
+			sockets.delete(socket);
+		});
+		if (isClosing) socket.destroy();
+	});
 	server.listen(err => {
 		if (err) return callback(err);
 		const addr = server.address();
@@ -67,7 +77,13 @@ module.exports = (compiler, client, callback) => {
 		);
 		callback(null, {
 			dispose(callback) {
-				server.close(callback);
+				isClosing = true;
+				server.close(err => {
+					callback(err);
+				});
+				for (const socket of sockets) {
+					socket.destroy(new Error("Server is disposing"));
+				}
 			},
 			module(originalModule) {
 				const key = `${encodeURIComponent(

package/lib/javascript/EnableChunkLoadingPlugin.js

@@ -96,9 +96,11 @@ class EnableChunkLoadingPlugin {
 					}).apply(compiler);
 					break;
 				}
-				case "import":
-					// TODO implement import chunk loading
-					throw new Error("Chunk Loading via import() is not implemented yet");
+				case "import": {
+					const ModuleChunkLoadingPlugin = require("../esm/ModuleChunkLoadingPlugin");
+					new ModuleChunkLoadingPlugin().apply(compiler);
+					break;
+				}
 				case "universal":
 					// TODO implement universal chunk loading
 					throw new Error("Universal Chunk Loading is not implemented yet");

package/lib/javascript/JavascriptModulesPlugin.js

@@ -17,6 +17,7 @@ const {
 const Compilation = require("../Compilation");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
+const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
@@ -84,6 +85,17 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {string} hash hash to be used for render call
  */
 
+/**
+ * @typedef {Object} ChunkRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
+ */
+
 /**
  * @typedef {Object} RenderBootstrapContext
  * @property {Chunk} chunk the chunk
@@ -97,11 +109,12 @@ const printGeneratedCodeForStack = (module, code) => {
 
 /**
  * @typedef {Object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, RenderContext]>} renderModuleContent
- * @property {SyncWaterfallHook<[Source, Module, RenderContext]>} renderModuleContainer
- * @property {SyncWaterfallHook<[Source, Module, RenderContext]>} renderModulePackage
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
  * @property {SyncWaterfallHook<[Source, RenderContext]>} render
  * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
  * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
@@ -145,6 +158,7 @@ class JavascriptModulesPlugin {
 					"renderContext"
 				]),
 				render: new SyncWaterfallHook(["source", "renderContext"]),
+				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
 				renderStartup: new SyncWaterfallHook([
 					"source",
 					"module",
@@ -462,7 +476,7 @@ class JavascriptModulesPlugin {
 
 	/**
 	 * @param {Module} module the rendered module
-	 * @param {RenderContext} renderContext options object
+	 * @param {ChunkRenderContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
 	 * @param {boolean | "strict"} factory true: renders as factory method, "strict": renders as factory method already in strict scope, false: pure module content
 	 * @returns {Source} the newly generated source from rendering
@@ -471,12 +485,16 @@ class JavascriptModulesPlugin {
 		const { chunk, chunkGraph, runtimeTemplate, codeGenerationResults } =
 			renderContext;
 		try {
-			const moduleSource = codeGenerationResults.getSource(
-				module,
-				chunk.runtime,
-				"javascript"
-			);
+			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+			const moduleSource = codeGenResult.sources.get("javascript");
 			if (!moduleSource) return null;
+			if (codeGenResult.data !== undefined) {
+				const chunkInitFragments = codeGenResult.data.get("chunkInitFragments");
+				if (chunkInitFragments) {
+					for (const i of chunkInitFragments)
+						renderContext.chunkInitFragments.push(i);
+				}
+			}
 			const moduleSourcePostContent = tryRunOrWebpackError(
 				() =>
 					hooks.renderModuleContent.call(moduleSource, module, renderContext),
@@ -580,20 +598,44 @@ class JavascriptModulesPlugin {
 			"javascript",
 			compareModulesByIdentifier
 		);
+		/** @type {ChunkRenderContext} */
+		const chunkRenderContext = {
+			...renderContext,
+			chunkInitFragments: []
+		};
 		const moduleSources =
 			Template.renderChunkModules(
-				renderContext,
+				chunkRenderContext,
 				modules ? Array.from(modules) : [],
-				module => this.renderModule(module, renderContext, hooks, true)
+				module => this.renderModule(module, chunkRenderContext, hooks, true)
 			) || new RawSource("{}");
 		let source = tryRunOrWebpackError(
-			() => hooks.renderChunk.call(moduleSources, renderContext),
+			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
 			"JavascriptModulesPlugin.getCompilationHooks().renderChunk"
 		);
 		source = tryRunOrWebpackError(
-			() => hooks.render.call(source, renderContext),
+			() => hooks.renderContent.call(source, chunkRenderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
+		);
+		if (!source) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
+			);
+		}
+		source = InitFragment.addToSource(
+			source,
+			chunkRenderContext.chunkInitFragments,
+			chunkRenderContext
+		);
+		source = tryRunOrWebpackError(
+			() => hooks.render.call(source, chunkRenderContext),
 			"JavascriptModulesPlugin.getCompilationHooks().render"
 		);
+		if (!source) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
+			);
+		}
 		chunk.rendered = true;
 		return new ConcatSource(source, ";");
 	}
@@ -607,6 +649,12 @@ class JavascriptModulesPlugin {
 	renderMain(renderContext, hooks, compilation) {
 		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 
+		/** @type {ChunkRenderContext} */
+		const chunkRenderContext = {
+			...renderContext,
+			chunkInitFragments: []
+		};
+
 		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 		const iife = runtimeTemplate.isIIFE();
 
@@ -654,14 +702,14 @@ class JavascriptModulesPlugin {
 		}
 
 		const chunkModules = Template.renderChunkModules(
-			renderContext,
+			chunkRenderContext,
 			inlinedModules
 				? allModules.filter(m => !inlinedModules.has(m))
 				: allModules,
 			module =>
 				this.renderModule(
 					module,
-					renderContext,
+					chunkRenderContext,
 					hooks,
 					allStrict ? "strict" : true
 				),
@@ -670,7 +718,8 @@ class JavascriptModulesPlugin {
 		if (
 			chunkModules ||
 			runtimeRequirements.has(RuntimeGlobals.moduleFactories) ||
-			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly)
+			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly) ||
+			runtimeRequirements.has(RuntimeGlobals.require)
 		) {
 			source.add(prefix + "var __webpack_modules__ = (");
 			source.add(chunkModules || "{}");
@@ -731,7 +780,7 @@ class JavascriptModulesPlugin {
 			for (const m of inlinedModules) {
 				const renderedModule = this.renderModule(
 					m,
-					renderContext,
+					chunkRenderContext,
 					hooks,
 					false
 				);
@@ -852,6 +901,20 @@ class JavascriptModulesPlugin {
 				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderMain plugins should return something"
 			);
 		}
+		finalSource = tryRunOrWebpackError(
+			() => hooks.renderContent.call(finalSource, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
+		);
+		if (!finalSource) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
+			);
+		}
+		finalSource = InitFragment.addToSource(
+			finalSource,
+			chunkRenderContext.chunkInitFragments,
+			chunkRenderContext
+		);
 		finalSource = tryRunOrWebpackError(
 			() => hooks.render.call(finalSource, renderContext),
 			"JavascriptModulesPlugin.getCompilationHooks().render"

package/lib/javascript/JavascriptParser.js

@@ -25,6 +25,8 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").Comment} CommentNode */
 /** @typedef {import("estree").ConditionalExpression} ConditionalExpressionNode */
 /** @typedef {import("estree").Declaration} DeclarationNode */
+/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifierNode */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinitionNode */
 /** @typedef {import("estree").Expression} ExpressionNode */
 /** @typedef {import("estree").Identifier} IdentifierNode */
 /** @typedef {import("estree").IfStatement} IfStatementNode */
@@ -128,7 +130,6 @@ const defaultParserOptions = {
 	locations: true,
 	ecmaVersion: "latest",
 	sourceType: "module",
-	allowAwaitOutsideFunction: true,
 	onComment: null
 };
 
@@ -175,11 +176,18 @@ class JavascriptParser extends Parser {
 			/** @type {SyncBailHook<[IfStatementNode], boolean | void>} */
 			statementIf: new SyncBailHook(["statement"]),
 			/** @type {SyncBailHook<[ExpressionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classExtendsExpression: new SyncBailHook(["expression", "statement"]),
+			classExtendsExpression: new SyncBailHook([
+				"expression",
+				"classDefinition"
+			]),
 			/** @type {SyncBailHook<[MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classBodyElement: new SyncBailHook(["element", "statement"]),
+			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
 			/** @type {SyncBailHook<[ExpressionNode, MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
-			classBodyValue: new SyncBailHook(["expression", "element", "statement"]),
+			classBodyValue: new SyncBailHook([
+				"expression",
+				"element",
+				"classDefinition"
+			]),
 			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
 			label: new HookMap(() => new SyncBailHook(["statement"])),
 			/** @type {SyncBailHook<[StatementNode, ImportSource], boolean | void>} */

package/lib/node/NodeTargetPlugin.js

@@ -55,6 +55,7 @@ const builtins = [
 	"wasi",
 	"worker_threads",
 	"zlib",
+	/^node:/,
 
 	// cspell:word pnpapi
 	// Yarn PnP adds pnpapi as "builtin"
@@ -68,7 +69,7 @@ class NodeTargetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin("commonjs", builtins).apply(compiler);
+		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
 	}
 }
 

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -12,6 +12,10 @@ const AsyncWasmChunkLoadingRuntimeModule = require("../wasm-async/AsyncWasmChunk
 /** @typedef {import("../Compiler")} Compiler */
 
 class ReadFileCompileAsyncWasmPlugin {
+	constructor({ type = "async-node", import: useImport = false } = {}) {
+		this._type = type;
+		this._import = useImport;
+	}
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -28,32 +32,50 @@ class ReadFileCompileAsyncWasmPlugin {
 						options && options.wasmLoading !== undefined
 							? options.wasmLoading
 							: globalWasmLoading;
-					return wasmLoading === "async-node";
+					return wasmLoading === this._type;
 				};
-				const generateLoadBinaryCode = path =>
-					Template.asString([
-						"new Promise(function (resolve, reject) {",
-						Template.indent([
-							"var { readFile } = require('fs');",
-							"var { join } = require('path');",
-							"",
-							"try {",
-							Template.indent([
-								`readFile(join(__dirname, ${path}), function(err, buffer){`,
+				const generateLoadBinaryCode = this._import
+					? path =>
+							Template.asString([
+								"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 								Template.indent([
-									"if (err) return reject(err);",
-									"",
-									"// Fake fetch response",
-									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
+									`readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
+									Template.indent([
+										"if (err) return reject(err);",
+										"",
+										"// Fake fetch response",
+										"resolve({",
+										Template.indent(["arrayBuffer() { return buffer; }"]),
+										"});"
+									]),
 									"});"
 								]),
-								"});"
-							]),
-							"} catch (err) { reject(err); }"
-						]),
-						"})"
-					]);
+								"}))"
+							])
+					: path =>
+							Template.asString([
+								"new Promise(function (resolve, reject) {",
+								Template.indent([
+									"try {",
+									Template.indent([
+										"var { readFile } = require('fs');",
+										"var { join } = require('path');",
+										"",
+										`readFile(join(__dirname, ${path}), function(err, buffer){`,
+										Template.indent([
+											"if (err) return reject(err);",
+											"",
+											"// Fake fetch response",
+											"resolve({",
+											Template.indent(["arrayBuffer() { return buffer; }"]),
+											"});"
+										]),
+										"});"
+									]),
+									"} catch (err) { reject(err); }"
+								]),
+								"})"
+							]);
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.instantiateWasm)

package/lib/optimize/InnerGraphPlugin.js

@@ -238,12 +238,25 @@ class InnerGraphPlugin {
 						}
 					);
 
+					parser.hooks.classBodyElement.tap(
+						"InnerGraphPlugin",
+						(element, classDefinition) => {
+							if (!InnerGraph.isEnabled(parser.state)) return;
+							if (parser.scope.topLevelScope === true) {
+								const fn = classWithTopLevelSymbol.get(classDefinition);
+								if (fn) {
+									InnerGraph.setTopLevelSymbol(parser.state, undefined);
+								}
+							}
+						}
+					);
+
 					parser.hooks.classBodyValue.tap(
 						"InnerGraphPlugin",
-						(expression, element, statement) => {
+						(expression, element, classDefinition) => {
 							if (!InnerGraph.isEnabled(parser.state)) return;
 							if (parser.scope.topLevelScope === true) {
-								const fn = classWithTopLevelSymbol.get(statement);
+								const fn = classWithTopLevelSymbol.get(classDefinition);
 								if (fn) {
 									if (
 										!element.static ||
@@ -253,6 +266,24 @@ class InnerGraphPlugin {
 										)
 									) {
 										InnerGraph.setTopLevelSymbol(parser.state, fn);
+										if (element.type !== "MethodDefinition" && element.static) {
+											InnerGraph.onUsage(parser.state, usedByExports => {
+												switch (usedByExports) {
+													case undefined:
+													case true:
+														return;
+													default: {
+														const dep = new PureExpressionDependency(
+															expression.range
+														);
+														dep.loc = expression.loc;
+														dep.usedByExports = usedByExports;
+														parser.state.module.addDependency(dep);
+														break;
+													}
+												}
+											});
+										}
 									} else {
 										InnerGraph.setTopLevelSymbol(parser.state, undefined);
 									}

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -450,7 +450,7 @@ class ModuleConcatenationPlugin {
 						},
 						err => {
 							logger.timeEnd("create concatenated modules");
-							process.nextTick(() => callback(err));
+							process.nextTick(callback.bind(null, err));
 						}
 					);
 				}

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -57,19 +57,23 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"completeQueue(queue);",
 								"queue = 0;"
 							])});`,
-							`var obj = { [webpackThen]: ${runtimeTemplate.expressionFunction(
+							`var obj = {};
+							obj[webpackThen] = ${runtimeTemplate.expressionFunction(
 								"queueFunction(queue, fn), dep.catch(reject)",
 								"fn, reject"
-							)} };`,
+							)};`,
 							"return obj;"
 						]),
 						"}"
 					]),
 					"}",
-					`return { [webpackThen]: ${runtimeTemplate.expressionFunction(
+					`var ret = {};
+					ret[webpackThen] = ${runtimeTemplate.expressionFunction(
 						"completeFunction(fn)",
 						"fn"
-					)}, [webpackExports]: dep };`
+					)};
+					ret[webpackExports] = dep;
+					return ret;`
 				])})`,
 				"deps"
 			)};`,