webpack 5.102.1 → 5.103.0

package/lib/library/SystemLibraryPlugin.js

@@ -164,6 +164,10 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 												`Object.defineProperty(${external}, "__esModule", { value: true });`
 											);
 										}
+										// See comment above
+										instructions.push(
+											`${external}["default"] = module["default"] || module;`
+										);
 										if (handledNames.length > 0) {
 											const name = `${external}handledNames`;
 											externalVarInitialization.push(

package/lib/library/UmdLibraryPlugin.js

@@ -338,7 +338,7 @@ class UmdLibraryPlugin extends AbstractLibraryPlugin {
 										: "		var a = factory();\n"
 								}		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];\n` +
 								"	}\n"
-					}})(${runtimeTemplate.outputOptions.globalObject}, ${
+					}})(${runtimeTemplate.globalObject}, ${
 						runtimeTemplate.supportsArrowFunction()
 							? `(${externalsArguments(externals)}) =>`
 							: `function(${externalsArguments(externals)})`

package/lib/node/NodeTargetPlugin.js

@@ -7,6 +7,7 @@
 
 const ExternalsPlugin = require("../ExternalsPlugin");
 
+/** @typedef {import("../../declarations/WebpackOptions").ExternalsType} ExternalsType */
 /** @typedef {import("../Compiler")} Compiler */
 
 const builtins = [
@@ -72,13 +73,20 @@ const builtins = [
 ];
 
 class NodeTargetPlugin {
+	/**
+	 * @param {ExternalsType} type default external type
+	 */
+	constructor(type = "node-commonjs") {
+		this.type = type;
+	}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
+		new ExternalsPlugin(this.type, builtins).apply(compiler);
 	}
 }
 

package/lib/node/ReadFileCompileWasmPlugin.js

@@ -19,8 +19,6 @@ const WasmChunkLoadingRuntimeModule = require("../wasm-sync/WasmChunkLoadingRunt
  * @property {boolean=} import use import?
  */
 
-// TODO webpack 6 remove
-
 const PLUGIN_NAME = "ReadFileCompileWasmPlugin";
 
 class ReadFileCompileWasmPlugin {

package/lib/optimize/ConcatenatedModule.js

@@ -22,8 +22,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { DEFAULTS } = require("../config/defaults");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
-const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
-const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
+const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
 const JavascriptParser = require("../javascript/JavascriptParser");
 const {
 	getMakeDeferredNamespaceModeFromExportsType,
@@ -167,6 +166,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {"external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {NonDeferAccess} nonDeferAccess
  * @property {number} index
  * @property {string | undefined} name module.exports / harmony namespace object
  * @property {string | undefined} deferredName deferred module.exports / harmony namespace object
@@ -185,6 +185,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @typedef {object} ReferenceToModuleInfo
  * @property {"reference"} type
  * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {NonDeferAccess} nonDeferAccess
  * @property {ModuleInfo} target
  */
 
@@ -223,16 +224,6 @@ const compareNumbers = (a, b) => {
 };
 const bySourceOrder = createComparator("sourceOrder", compareNumbers);
 const byRangeStart = createComparator("rangeStart", compareNumbers);
-const moveDeferToLast = (
-	/** @type {{ defer?: boolean }} */ a,
-	/** @type {{ defer?: boolean }} */ b
-) => {
-	if (a.defer === b.defer) return 0;
-	if (a.defer) return 1;
-	return -1;
-};
-
-const INITIAL_USED_NAMES = new Set(RESERVED_NAMES);
 
 /**
  * @param {Iterable<string>} iterable iterable object
@@ -254,11 +245,28 @@ const joinIterableWithComma = (iterable) => {
 	return str;
 };
 
+/** @typedef {boolean} NonDeferAccess */
+
+/**
+ * @param {NonDeferAccess} a a
+ * @param {NonDeferAccess} b b
+ * @returns {NonDeferAccess} merged
+ */
+const mergeNonDeferAccess = (a, b) => a || b;
+
+/**
+ * @param {NonDeferAccess} a first
+ * @param {NonDeferAccess} b second
+ * @returns {NonDeferAccess} first - second
+ */
+const subtractNonDeferAccess = (a, b) => a && !b;
+
 /**
  * @typedef {object} ConcatenationEntry
  * @property {"concatenated" | "external"} type
  * @property {Module} module
  * @property {RuntimeSpec | boolean} runtimeCondition
+ * @property {NonDeferAccess} nonDeferAccess
  */
 
 /** @typedef {Set<ConcatenatedModuleInfo>} NeededNamespaceObjects */
@@ -300,11 +308,11 @@ const getFinalBinding = (
 		moduleGraph,
 		strictHarmonyModule
 	);
-	const deferred =
-		depDeferred &&
+	const moduleDeferred =
 		info.type === "external" &&
 		info.deferred &&
-		!moduleGraph.isAsync(info.module);
+		!(/** @type {BuildMeta} */ (info.module.buildMeta).async);
+	const deferred = depDeferred && moduleDeferred;
 	if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
@@ -391,6 +399,14 @@ const getFinalBinding = (
 								exportName
 							};
 						}
+						if (moduleDeferred) {
+							return {
+								info,
+								rawName: /** @type {string} */ (info.name),
+								ids: exportName,
+								exportName
+							};
+						}
 						info.interopDefaultAccessUsed = true;
 						const defaultExport = asCall
 							? `${info.interopDefaultAccessName}()`
@@ -951,13 +967,12 @@ class ConcatenatedModule extends Module {
 	_createConcatenationList(rootModule, modulesSet, runtime, moduleGraph) {
 		/** @type {ConcatenationEntry[]} */
 		const list = [];
-		/** @type {Map<Module, RuntimeSpec | true>} */
+		/** @type {Map<Module, { runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} */
 		const existingEntries = new Map();
-		const deferEnabled = this.compilation.options.experiments.deferImport;
 
 		/**
 		 * @param {Module} module a module
-		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} imported modules in order
+		 * @returns {Iterable<{ connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} imported modules in order
 		 */
 		const getConcatenatedImports = (module) => {
 			const connections = [...moduleGraph.getOutgoingConnections(module)];
@@ -987,9 +1002,9 @@ class ConcatenatedModule extends Module {
 						(connection.dependency);
 					return {
 						connection,
-						sourceOrder: dep.sourceOrder,
+						sourceOrder: /** @type {number} */ (dep.sourceOrder),
 						rangeStart: dep.range && dep.range[0],
-						defer: dep.defer
+						defer: ImportPhaseUtils.isDefer(dep.phase)
 					};
 				});
 			/**
@@ -1004,27 +1019,27 @@ class ConcatenatedModule extends Module {
 			 * a.a(); // first range
 			 * b.b(); // second range
 			 *
-			 * If the import is deferred, we always move it to the last.
 			 * If there is no reexport, we have the same source.
 			 * If there is reexport, but module has side effects, this will lead to reexport module only.
 			 * If there is side-effects-free reexport, we can get simple deterministic result with range start comparison.
 			 */
 			references.sort(concatComparators(bySourceOrder, byRangeStart));
-			if (deferEnabled) {
-				// do not combine those two sorts. defer is not the same as source or range which has a comparable number, defer is only moving them.
-				references.sort(moveDeferToLast);
-			}
-			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true }>} */
+			/** @type {Map<Module, { connection: ModuleGraphConnection, runtimeCondition: RuntimeSpec | true, nonDeferAccess: NonDeferAccess }>} */
 			const referencesMap = new Map();
-			for (const { connection } of references) {
+			for (const { connection, defer } of references) {
 				const runtimeCondition = filterRuntime(runtime, (r) =>
 					connection.isTargetActive(r)
 				);
 				if (runtimeCondition === false) continue;
+				const nonDeferAccess = !defer;
 				const module = connection.module;
 				const entry = referencesMap.get(module);
 				if (entry === undefined) {
-					referencesMap.set(module, { connection, runtimeCondition });
+					referencesMap.set(module, {
+						connection,
+						runtimeCondition,
+						nonDeferAccess
+					});
 					continue;
 				}
 				entry.runtimeCondition = mergeRuntimeConditionNonFalse(
@@ -1032,6 +1047,10 @@ class ConcatenatedModule extends Module {
 					runtimeCondition,
 					runtime
 				);
+				entry.nonDeferAccess = mergeNonDeferAccess(
+					entry.nonDeferAccess,
+					nonDeferAccess
+				);
 			}
 			return referencesMap.values();
 		};
@@ -1039,17 +1058,25 @@ class ConcatenatedModule extends Module {
 		/**
 		 * @param {ModuleGraphConnection} connection graph connection
 		 * @param {RuntimeSpec | true} runtimeCondition runtime condition
+		 * @param {NonDeferAccess} nonDeferAccess non-defer access
 		 * @returns {void}
 		 */
-		const enterModule = (connection, runtimeCondition) => {
+		const enterModule = (connection, runtimeCondition, nonDeferAccess) => {
 			const module = connection.module;
 			if (!module) return;
 			const existingEntry = existingEntries.get(module);
-			if (existingEntry === true) {
+			if (
+				existingEntry &&
+				existingEntry.runtimeCondition === true &&
+				existingEntry.nonDeferAccess === true
+			) {
 				return;
 			}
 			if (modulesSet.has(module)) {
-				existingEntries.set(module, true);
+				existingEntries.set(module, {
+					runtimeCondition: true,
+					nonDeferAccess: true
+				});
 				if (runtimeCondition !== true) {
 					throw new Error(
 						`Cannot runtime-conditional concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}, ${runtimeConditionToString(
@@ -1057,34 +1084,66 @@ class ConcatenatedModule extends Module {
 						)}). This should not happen.`
 					);
 				}
+				if (nonDeferAccess !== true) {
+					throw new Error(
+						`Cannot deferred concatenate a module (${module.identifier()} in ${this.rootModule.identifier()}. This should not happen.`
+					);
+				}
 				const imports = getConcatenatedImports(module);
-				for (const { connection, runtimeCondition } of imports) {
-					enterModule(connection, runtimeCondition);
+				for (const {
+					connection,
+					runtimeCondition,
+					nonDeferAccess
+				} of imports) {
+					enterModule(connection, runtimeCondition, nonDeferAccess);
 				}
 				list.push({
 					type: "concatenated",
 					module: connection.module,
-					runtimeCondition
+					runtimeCondition,
+					nonDeferAccess
 				});
 			} else {
+				/** @type {RuntimeSpec | boolean} */
+				let reducedRuntimeCondition;
+				/** @type {NonDeferAccess} */
+				let reducedNonDeferAccess;
 				if (existingEntry !== undefined) {
-					const reducedRuntimeCondition = subtractRuntimeCondition(
+					reducedRuntimeCondition = subtractRuntimeCondition(
 						runtimeCondition,
-						existingEntry,
+						existingEntry.runtimeCondition,
 						runtime
 					);
-					if (reducedRuntimeCondition === false) return;
-					runtimeCondition = reducedRuntimeCondition;
-					existingEntries.set(
-						connection.module,
-						mergeRuntimeConditionNonFalse(
-							existingEntry,
-							runtimeCondition,
-							runtime
-						)
+					reducedNonDeferAccess = subtractNonDeferAccess(
+						nonDeferAccess,
+						existingEntry.nonDeferAccess
 					);
+					if (
+						reducedRuntimeCondition === false &&
+						reducedNonDeferAccess === false
+					) {
+						return;
+					}
+					if (reducedRuntimeCondition !== false) {
+						existingEntry.runtimeCondition = mergeRuntimeConditionNonFalse(
+							existingEntry.runtimeCondition,
+							reducedRuntimeCondition,
+							runtime
+						);
+					}
+					if (reducedNonDeferAccess !== false) {
+						existingEntry.nonDeferAccess = mergeNonDeferAccess(
+							existingEntry.nonDeferAccess,
+							reducedNonDeferAccess
+						);
+					}
 				} else {
-					existingEntries.set(connection.module, runtimeCondition);
+					reducedRuntimeCondition = runtimeCondition;
+					reducedNonDeferAccess = nonDeferAccess;
+					existingEntries.set(connection.module, {
+						runtimeCondition,
+						nonDeferAccess
+					});
 				}
 				if (list.length > 0) {
 					const lastItem = list[list.length - 1];
@@ -1094,9 +1153,13 @@ class ConcatenatedModule extends Module {
 					) {
 						lastItem.runtimeCondition = mergeRuntimeCondition(
 							lastItem.runtimeCondition,
-							runtimeCondition,
+							reducedRuntimeCondition,
 							runtime
 						);
+						lastItem.nonDeferAccess = mergeNonDeferAccess(
+							lastItem.nonDeferAccess,
+							reducedNonDeferAccess
+						);
 						return;
 					}
 				}
@@ -1108,20 +1171,25 @@ class ConcatenatedModule extends Module {
 						// concatenated module)
 						return connection.module;
 					},
-					runtimeCondition
+					runtimeCondition: reducedRuntimeCondition,
+					nonDeferAccess: reducedNonDeferAccess
 				});
 			}
 		};
 
-		existingEntries.set(rootModule, true);
+		existingEntries.set(rootModule, {
+			runtimeCondition: true,
+			nonDeferAccess: true
+		});
 		const imports = getConcatenatedImports(rootModule);
-		for (const { connection, runtimeCondition } of imports) {
-			enterModule(connection, runtimeCondition);
+		for (const { connection, runtimeCondition, nonDeferAccess } of imports) {
+			enterModule(connection, runtimeCondition, nonDeferAccess);
 		}
 		list.push({
 			type: "concatenated",
 			module: rootModule,
-			runtimeCondition: true
+			runtimeCondition: true,
+			nonDeferAccess: true
 		});
 
 		return list;
@@ -1207,18 +1275,8 @@ class ConcatenatedModule extends Module {
 		/** @type {NeededNamespaceObjects} */
 		const neededNamespaceObjects = new Set();
 
-		// Default disallowed names
-		const allUsedNames = new Set(INITIAL_USED_NAMES);
-		const chunks = chunkGraph.getModuleChunks(this);
-
-		// Add names already used in the current chunk scope
-		for (const chunk of chunks) {
-			if (ConcatenationScope.chunkUsedNames.has(chunk)) {
-				for (const name of ConcatenationScope.chunkUsedNames.get(chunk) || []) {
-					allUsedNames.add(name);
-				}
-			}
-		}
+		// List of all used names to avoid conflicts
+		const allUsedNames = new Set(RESERVED_NAMES);
 
 		// Generate source code and analyse scopes
 		// Prepare a ReplaceSource for the final source
@@ -1237,23 +1295,6 @@ class ConcatenatedModule extends Module {
 			);
 		}
 
-		// Record the names registered by the current ConcatenatedModule into the chunk scope
-		if (INITIAL_USED_NAMES.size !== allUsedNames.size) {
-			for (const name of allUsedNames) {
-				if (INITIAL_USED_NAMES.has(name)) continue;
-
-				for (const chunk of chunks) {
-					if (!ConcatenationScope.chunkUsedNames.has(chunk)) {
-						ConcatenationScope.chunkUsedNames.set(chunk, new Set([name]));
-					} else {
-						/** @type {Set<string>} */ (
-							ConcatenationScope.chunkUsedNames.get(chunk)
-						).add(name);
-					}
-				}
-			}
-		}
-
 		// Updated Top level declarations are created by renaming
 		/** @type {TopLevelDeclarations} */
 		const topLevelDeclarations = new Set();
@@ -1837,26 +1878,37 @@ ${defineGetters}`
 			if (info.type === "external" && info.deferred) {
 				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
 				const loader = getOptimizedDeferredModule(
-					runtimeTemplate,
+					moduleId,
 					info.module.getExportsType(
 						moduleGraph,
 						/** @type {BuildMeta} */
 						(this.rootModule.buildMeta).strictHarmonyModule
 					),
-					moduleId,
 					// an async module will opt-out of the concat module optimization.
-					[]
+					[],
+					runtimeRequirements
 				);
 				runtimeRequirements.add(RuntimeGlobals.require);
 				result.add(
 					`\n// DEFERRED EXTERNAL MODULE: ${info.module.readableIdentifier(requestShortener)}\nvar ${info.deferredName} = ${loader};`
 				);
+				if (info.deferredNamespaceObjectUsed) {
+					runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+					result.add(
+						`\nvar ${info.deferredNamespaceObjectName} = /*#__PURE__*/${
+							RuntimeGlobals.makeDeferredNamespaceObject
+						}(${JSON.stringify(
+							chunkGraph.getModuleId(info.module)
+						)}, ${getMakeDeferredNamespaceModeFromExportsType(
+							info.module.getExportsType(moduleGraph, strictHarmonyModule)
+						)});`
+					);
+				}
 			}
 		}
 
 		/** @type {InitFragment<ChunkRenderContext>[]} */
 		const chunkInitFragments = [];
-		const deferEnabled = this.compilation.options.experiments.deferImport;
 
 		// evaluate modules in order
 		for (const rawInfo of modulesWithInfo) {
@@ -1868,41 +1920,6 @@ ${defineGetters}`
 					result.add(
 						`\n;// ${info.module.readableIdentifier(requestShortener)}\n`
 					);
-					// If a module is deferred in other places, but used as non-deferred here,
-					// the module itself will be emitted as mod_deferred (in the case "external"),
-					// we need to emit an extra import declaration to evaluate it in order.
-					if (deferEnabled) {
-						for (const dep of info.module.dependencies) {
-							if (
-								!(/** @type {HarmonyImportDependency} */ (dep).defer) &&
-								(dep instanceof HarmonyImportSideEffectDependency ||
-									dep instanceof HarmonyImportSpecifierDependency)
-							) {
-								const referredModule = moduleGraph.getModule(dep);
-								if (!referredModule) {
-									if (dep instanceof HarmonyImportSideEffectDependency) {
-										continue;
-									} else {
-										throw new Error(
-											"Deferred module used, but no module in the graph."
-										);
-									}
-								}
-								if (moduleGraph.isDeferred(referredModule)) {
-									const deferredModuleInfo = /** @type {ExternalModuleInfo} */ (
-										modulesWithInfo.find(
-											(i) =>
-												i.type === "external" && i.module === referredModule
-										)
-									);
-									if (!deferredModuleInfo) continue;
-									result.add(
-										`\n// non-deferred import to a deferred module (${referredModule.readableIdentifier(requestShortener)})\nvar ${deferredModuleInfo.name} = ${deferredModuleInfo.deferredName}.a;`
-									);
-								}
-							}
-						}
-					}
 					result.add(/** @type {ReplaceSource} */ (info.source));
 					if (info.chunkInitFragments) {
 						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
@@ -1943,24 +1960,23 @@ ${defineGetters}`
 						result.add(`var ${info.name} = __webpack_require__(${moduleId});`);
 						name = info.name;
 					}
+					// If a module is deferred in other places, but used as non-deferred here,
+					// the module itself will be emitted as mod_deferred (in the case "external"),
+					// we need to emit an extra import declaration to evaluate it in order.
+					const { nonDeferAccess } =
+						/** @type {ExternalModuleInfo | ReferenceToModuleInfo} */
+						(rawInfo);
+					if (info.deferred && nonDeferAccess) {
+						result.add(
+							`\n// non-deferred import to a deferred module (${info.module.readableIdentifier(requestShortener)})\nvar ${info.name} = ${info.deferredName}.a;`
+						);
+					}
 					break;
 				}
 				default:
 					// @ts-expect-error never is expected here
 					throw new Error(`Unsupported concatenation entry type ${info.type}`);
 			}
-			if (info.type === "external" && info.deferredNamespaceObjectUsed) {
-				runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
-				result.add(
-					`\nvar ${info.deferredNamespaceObjectName} = /*#__PURE__*/${
-						RuntimeGlobals.makeDeferredNamespaceObject
-					}(${JSON.stringify(
-						chunkGraph.getModuleId(info.module)
-					)}, ${getMakeDeferredNamespaceModeFromExportsType(
-						info.module.getExportsType(moduleGraph, strictHarmonyModule)
-					)});`
-				);
-			}
 			if (info.interopNamespaceObjectUsed) {
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				result.add(
@@ -2049,11 +2065,19 @@ ${defineGetters}`
 				const data = codeGenResult.data;
 				const chunkInitFragments = data && data.get("chunkInitFragments");
 				const code = source.source().toString();
+
+				/** @type {Program} */
 				let ast;
+
 				try {
-					ast = JavascriptParser._parse(code, {
-						sourceType: "module"
-					});
+					({ ast } = JavascriptParser._parse(
+						code,
+						{
+							sourceType: "module",
+							ranges: true
+						},
+						JavascriptParser._getModuleParseFunction(this.compilation, m)
+					));
 				} catch (_err) {
 					const err =
 						/** @type {Error & { loc?: { line: number, column: number } }} */
@@ -2148,6 +2172,7 @@ ${defineGetters}`
 							type: "external",
 							module: info.module,
 							runtimeCondition: info.runtimeCondition,
+							nonDeferAccess: info.nonDeferAccess,
 							index,
 							name: undefined,
 							deferredName: undefined,
@@ -2177,6 +2202,7 @@ ${defineGetters}`
 			const ref = {
 				type: "reference",
 				runtimeCondition: info.runtimeCondition,
+				nonDeferAccess: info.nonDeferAccess,
 				target: item
 			};
 			return ref;

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -35,10 +35,28 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 			}hasSymbol ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
 			'var webpackError = hasSymbol ? Symbol("webpack error") : "__webpack_error__";',
 			defer
-				? `var webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`
-				: "",
-			defer
-				? `var webpackDefer = ${RuntimeGlobals.makeDeferredNamespaceObjectSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`
+				? Template.asString([
+						`var webpackDone = ${RuntimeGlobals.asyncModuleDoneSymbol} = hasSymbol ? Symbol("webpack done") : "__webpack_done__";`,
+						`var webpackDefer = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol} = hasSymbol ? Symbol("webpack defer") : "__webpack_defer__";`,
+						`${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies} = ${runtimeTemplate.basicFunction(
+							"asyncDeps",
+							[
+								Template.indent([
+									"var hasUnresolvedAsyncSubgraph = asyncDeps.some((id) => {",
+									Template.indent([
+										"var cache = __webpack_module_cache__[id];",
+										"return !cache || cache[webpackDone] === false;"
+									]),
+									"});",
+									"if (hasUnresolvedAsyncSubgraph) {",
+									Template.indent([
+										"return ({ then(onFulfilled, onRejected) { return Promise.all(asyncDeps.map(__webpack_require__)).then(onFulfilled, onRejected) } })"
+									]),
+									"}"
+								])
+							]
+						)}`
+					])
 				: "",
 			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
 				"if(queue && queue.d < 1) {",
@@ -63,25 +81,17 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 							? Template.asString([
 									"if(!dep[webpackQueues] && dep[webpackDefer]) {",
 									Template.indent([
-										"var asyncDeps = dep[webpackDefer];",
-										`var hasUnresolvedAsyncSubgraph = asyncDeps.some(${runtimeTemplate.basicFunction(
-											"id",
-											[
-												"var cache = __webpack_module_cache__[id];",
-												"return !cache || cache[webpackDone] === false;"
-											]
-										)});`,
-										"if (hasUnresolvedAsyncSubgraph) {",
+										`var asyncDeps = ${RuntimeGlobals.deferredModuleAsyncTransitiveDependencies}(dep[webpackDefer]);`,
+										"if (asyncDeps) {",
 										Template.indent([
 											"var d = dep;",
 											"dep = {",
 											Template.indent([
-												"then(callback) {",
+												"then(onFulfilled, onRejected) {",
 												Template.indent([
-													"Promise.all(asyncDeps.map(__webpack_require__))",
-													`.then(${runtimeTemplate.returningFunction(
-														"callback(d)"
-													)});`
+													`asyncDeps.then(${runtimeTemplate.returningFunction(
+														"onFulfilled(d)"
+													)}, onRejected);`
 												]),
 												"}"
 											]),

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -23,7 +23,8 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 	 */
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
-		const { scriptType, importMetaName, path } = compilation.outputOptions;
+		const { scriptType, importMetaName, path, environment } =
+			compilation.outputOptions;
 		const chunkName = compilation.getPath(
 			JavascriptModulesPlugin.getChunkFilenameTemplate(
 				/** @type {Chunk} */
@@ -41,13 +42,17 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 			false
 		);
 
+		const global = environment.globalThis
+			? "globalThis"
+			: RuntimeGlobals.global;
+
 		return Template.asString([
 			"var scriptUrl;",
 			scriptType === "module"
 				? `if (typeof ${importMetaName}.url === "string") scriptUrl = ${importMetaName}.url`
 				: Template.asString([
-						`if (${RuntimeGlobals.global}.importScripts) scriptUrl = ${RuntimeGlobals.global}.location + "";`,
-						`var document = ${RuntimeGlobals.global}.document;`,
+						`if (${global}.importScripts) scriptUrl = ${global}.location + "";`,
+						`var document = ${global}.document;`,
 						"if (!scriptUrl && document) {",
 						Template.indent([
 							// Technically we could use `document.currentScript instanceof window.HTMLScriptElement`,