webpack 5.66.0 → 5.69.1

package/lib/ids/NamedModuleIdsPlugin.js

@@ -10,7 +10,7 @@ const {
 	getShortModuleName,
 	getLongModuleName,
 	assignNames,
-	getUsedModuleIds,
+	getUsedModuleIdsAndModules,
 	assignAscendingModuleIds
 } = require("./IdHelpers");
 
@@ -31,27 +31,24 @@ class NamedModuleIdsPlugin {
 		const { root } = compiler;
 		compiler.hooks.compilation.tap("NamedModuleIdsPlugin", compilation => {
 			const { hashFunction } = compilation.outputOptions;
-			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", modules => {
+			compilation.hooks.moduleIds.tap("NamedModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
 					? this.options.context
 					: compiler.context;
 
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
 				const unnamedModules = assignNames(
-					Array.from(modules).filter(module => {
-						if (!module.needId) return false;
-						if (chunkGraph.getNumberOfModuleChunks(module) === 0) return false;
-						return chunkGraph.getModuleId(module) === null;
-					}),
+					modules,
 					m => getShortModuleName(m, context, root),
 					(m, shortName) =>
 						getLongModuleName(shortName, m, context, hashFunction, root),
 					compareModulesByIdentifier,
-					getUsedModuleIds(compilation),
+					usedIds,
 					(m, name) => chunkGraph.setModuleId(m, name)
 				);
 				if (unnamedModules.length > 0) {
-					assignAscendingModuleIds(unnamedModules, compilation);
+					assignAscendingModuleIds(usedIds, unnamedModules, compilation);
 				}
 			});
 		});

package/lib/ids/NaturalModuleIdsPlugin.js

@@ -8,7 +8,10 @@
 const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
-const { assignAscendingModuleIds } = require("./IdHelpers");
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = require("./IdHelpers");
 
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -22,18 +25,12 @@ class NaturalModuleIdsPlugin {
 	apply(compiler) {
 		compiler.hooks.compilation.tap("NaturalModuleIdsPlugin", compilation => {
 			compilation.hooks.moduleIds.tap("NaturalModuleIdsPlugin", modules => {
-				const chunkGraph = compilation.chunkGraph;
-				const modulesInNaturalOrder = Array.from(modules)
-					.filter(
-						m =>
-							m.needId &&
-							chunkGraph.getNumberOfModuleChunks(m) > 0 &&
-							chunkGraph.getModuleId(m) === null
-					)
-					.sort(
-						compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-					);
-				assignAscendingModuleIds(modulesInNaturalOrder, compilation);
+				const [usedIds, modulesInNaturalOrder] =
+					getUsedModuleIdsAndModules(compilation);
+				modulesInNaturalOrder.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
+				assignAscendingModuleIds(usedIds, modulesInNaturalOrder, compilation);
 			});
 		});
 	}

package/lib/ids/OccurrenceModuleIdsPlugin.js

@@ -9,7 +9,10 @@ const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
-const { assignAscendingModuleIds } = require("./IdHelpers");
+const {
+	assignAscendingModuleIds,
+	getUsedModuleIdsAndModules
+} = require("./IdHelpers");
 
 /** @typedef {import("../../declarations/plugins/ids/OccurrenceModuleIdsPlugin").OccurrenceModuleIdsPluginOptions} OccurrenceModuleIdsPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
@@ -44,15 +47,11 @@ class OccurrenceModuleIdsPlugin {
 		compiler.hooks.compilation.tap("OccurrenceModuleIdsPlugin", compilation => {
 			const moduleGraph = compilation.moduleGraph;
 
-			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", modules => {
+			compilation.hooks.moduleIds.tap("OccurrenceModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 
-				const modulesInOccurrenceOrder = Array.from(modules).filter(
-					m =>
-						m.needId &&
-						chunkGraph.getNumberOfModuleChunks(m) > 0 &&
-						chunkGraph.getModuleId(m) === null
-				);
+				const [usedIds, modulesInOccurrenceOrder] =
+					getUsedModuleIdsAndModules(compilation);
 
 				const occursInInitialChunksMap = new Map();
 				const occursInAllChunksMap = new Map();
@@ -121,7 +120,7 @@ class OccurrenceModuleIdsPlugin {
 					}
 				}
 
-				for (const m of modules) {
+				for (const m of modulesInOccurrenceOrder) {
 					const result =
 						countOccurs(m) +
 						chunkGraph.getNumberOfModuleChunks(m) +
@@ -147,7 +146,11 @@ class OccurrenceModuleIdsPlugin {
 					return naturalCompare(a, b);
 				});
 
-				assignAscendingModuleIds(modulesInOccurrenceOrder, compilation);
+				assignAscendingModuleIds(
+					usedIds,
+					modulesInOccurrenceOrder,
+					compilation
+				);
 			});
 		});
 	}

package/lib/ids/SyncModuleIdsPlugin.js

@@ -0,0 +1,140 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { WebpackError } = require("..");
+const { getUsedModuleIdsAndModules } = require("./IdHelpers");
+
+/** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Module")} Module */
+
+const plugin = "SyncModuleIdsPlugin";
+
+class SyncModuleIdsPlugin {
+	/**
+	 * @param {Object} options options
+	 * @param {string} options.path path to file
+	 * @param {string=} options.context context for module names
+	 * @param {function(Module): boolean} options.test selector for modules
+	 * @param {"read" | "create" | "merge" | "update"=} options.mode operation mode (defaults to merge)
+	 */
+	constructor({ path, context, test, mode }) {
+		this._path = path;
+		this._context = context;
+		this._test = test || (() => true);
+		const readAndWrite = !mode || mode === "merge" || mode === "update";
+		this._read = readAndWrite || mode === "read";
+		this._write = readAndWrite || mode === "create";
+		this._prune = mode === "update";
+	}
+
+	/**
+	 * Apply the plugin
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		/** @type {Map<string, string | number>} */
+		let data;
+		let dataChanged = false;
+		if (this._read) {
+			compiler.hooks.readRecords.tapAsync(plugin, callback => {
+				const fs = compiler.intermediateFileSystem;
+				fs.readFile(this._path, (err, buffer) => {
+					if (err) {
+						if (err.code !== "ENOENT") {
+							return callback(err);
+						}
+						return callback();
+					}
+					const json = JSON.parse(buffer.toString());
+					data = new Map();
+					for (const key of Object.keys(json)) {
+						data.set(key, json[key]);
+					}
+					dataChanged = false;
+					return callback();
+				});
+			});
+		}
+		if (this._write) {
+			compiler.hooks.emitRecords.tapAsync(plugin, callback => {
+				if (!data || !dataChanged) return callback();
+				const json = {};
+				const sorted = Array.from(data).sort(([a], [b]) => (a < b ? -1 : 1));
+				for (const [key, value] of sorted) {
+					json[key] = value;
+				}
+				const fs = compiler.intermediateFileSystem;
+				fs.writeFile(this._path, JSON.stringify(json), callback);
+			});
+		}
+		compiler.hooks.thisCompilation.tap(plugin, compilation => {
+			const associatedObjectForCache = compiler.root;
+			const context = this._context || compiler.context;
+			if (this._read) {
+				compilation.hooks.reviveModules.tap(plugin, (_1, _2) => {
+					if (!data) return;
+					const { chunkGraph } = compilation;
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this._test
+					);
+					for (const module of modules) {
+						const name = module.libIdent({
+							context,
+							associatedObjectForCache
+						});
+						if (!name) continue;
+						const id = data.get(name);
+						const idAsString = `${id}`;
+						if (usedIds.has(idAsString)) {
+							const err = new WebpackError(
+								`SyncModuleIdsPlugin: Unable to restore id '${id}' from '${this._path}' as it's already used.`
+							);
+							err.module = module;
+							compilation.errors.push(err);
+						}
+						chunkGraph.setModuleId(module, id);
+						usedIds.add(idAsString);
+					}
+				});
+			}
+			if (this._write) {
+				compilation.hooks.recordModules.tap(plugin, modules => {
+					const { chunkGraph } = compilation;
+					let oldData = data;
+					if (!oldData) {
+						oldData = data = new Map();
+					} else if (this._prune) {
+						data = new Map();
+					}
+					for (const module of modules) {
+						if (this._test(module)) {
+							const name = module.libIdent({
+								context,
+								associatedObjectForCache
+							});
+							if (!name) continue;
+							const id = chunkGraph.getModuleId(module);
+							if (id === null) continue;
+							const oldId = oldData.get(name);
+							if (oldId !== id) {
+								dataChanged = true;
+							} else if (data === oldData) {
+								continue;
+							}
+							data.set(name, id);
+						}
+					}
+					if (data.size !== oldData.size) dataChanged = true;
+				});
+			}
+		});
+	}
+}
+
+module.exports = SyncModuleIdsPlugin;

package/lib/index.js

@@ -11,6 +11,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").Entry} Entry */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} EntryNormalized */
 /** @typedef {import("../declarations/WebpackOptions").EntryObject} EntryObject */
+/** @typedef {import("../declarations/WebpackOptions").FileCacheOptions} FileCacheOptions */
 /** @typedef {import("../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
@@ -26,11 +27,15 @@ const memoize = require("./util/memoize");
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
 /** @typedef {import("./Compilation").Asset} Asset */
 /** @typedef {import("./Compilation").AssetInfo} AssetInfo */
+/** @typedef {import("./Compilation").EntryOptions} EntryOptions */
+/** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
 /** @typedef {import("./MultiStats")} MultiStats */
 /** @typedef {import("./Parser").ParserState} ParserState */
 /** @typedef {import("./ResolverFactory").ResolvePluginInstance} ResolvePluginInstance */
 /** @typedef {import("./ResolverFactory").Resolver} Resolver */
 /** @typedef {import("./Watching")} Watching */
+/** @typedef {import("./cli").Argument} Argument */
+/** @typedef {import("./cli").Problem} Problem */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsAsset} StatsAsset */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunk} StatsChunk */
 /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsChunkGroup} StatsChunkGroup */
@@ -564,6 +569,11 @@ module.exports = mergeExports(fn, {
 			get HttpUriPlugin() {
 				return require("./schemes/HttpUriPlugin");
 			}
+		},
+		ids: {
+			get SyncModuleIdsPlugin() {
+				return require("./ids/SyncModuleIdsPlugin");
+			}
 		}
 	}
 });

package/lib/javascript/JavascriptModulesPlugin.js

@@ -24,6 +24,7 @@ const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const createHash = require("../util/createHash");
+const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 const { intersectRuntime } = require("../util/runtime");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptParser = require("./JavascriptParser");
@@ -102,6 +103,7 @@ const printGeneratedCodeForStack = (module, code) => {
 /**
  * @typedef {Object} RenderBootstrapContext
  * @property {Chunk} chunk the chunk
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
  * @property {RuntimeTemplate} runtimeTemplate the runtime template
  * @property {ModuleGraph} moduleGraph the module graph
  * @property {ChunkGraph} chunkGraph the chunk graph
@@ -331,6 +333,7 @@ class JavascriptModulesPlugin {
 								{
 									hash: "0000",
 									chunk,
+									codeGenerationResults: context.codeGenerationResults,
 									chunkGraph: context.chunkGraph,
 									moduleGraph: context.moduleGraph,
 									runtimeTemplate: context.runtimeTemplate
@@ -343,6 +346,7 @@ class JavascriptModulesPlugin {
 				compilation.hooks.contentHash.tap("JavascriptModulesPlugin", chunk => {
 					const {
 						chunkGraph,
+						codeGenerationResults,
 						moduleGraph,
 						runtimeTemplate,
 						outputOptions: {
@@ -360,6 +364,7 @@ class JavascriptModulesPlugin {
 							{
 								hash: "0000",
 								chunk,
+								codeGenerationResults,
 								chunkGraph: compilation.chunkGraph,
 								moduleGraph: compilation.moduleGraph,
 								runtimeTemplate: compilation.runtimeTemplate
@@ -372,6 +377,7 @@ class JavascriptModulesPlugin {
 					}
 					hooks.chunkHash.call(chunk, hash, {
 						chunkGraph,
+						codeGenerationResults,
 						moduleGraph,
 						runtimeTemplate
 					});
@@ -398,7 +404,10 @@ class JavascriptModulesPlugin {
 						xor.updateHash(hash);
 					}
 					const digest = /** @type {string} */ (hash.digest(hashDigest));
-					chunk.contentHash.javascript = digest.substr(0, hashDigestLength);
+					chunk.contentHash.javascript = nonNumericOnlyHash(
+						digest,
+						hashDigestLength
+					);
 				});
 				compilation.hooks.additionalTreeRuntimeRequirements.tap(
 					"JavascriptModulesPlugin",
@@ -974,7 +983,13 @@ class JavascriptModulesPlugin {
 	 * @returns {{ header: string[], beforeStartup: string[], startup: string[], afterStartup: string[], allowInlineStartup: boolean }} the generated source of the bootstrap code
 	 */
 	renderBootstrap(renderContext, hooks) {
-		const { chunkGraph, moduleGraph, chunk, runtimeTemplate } = renderContext;
+		const {
+			chunkGraph,
+			codeGenerationResults,
+			moduleGraph,
+			chunk,
+			runtimeTemplate
+		} = renderContext;
 
 		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 
@@ -1098,8 +1113,18 @@ class JavascriptModulesPlugin {
 						);
 						result.allowInlineStartup = false;
 					}
+
+					let data;
+					if (codeGenerationResults.has(entryModule, chunk.runtime)) {
+						const result = codeGenerationResults.get(
+							entryModule,
+							chunk.runtime
+						);
+						data = result.data;
+					}
 					if (
 						result.allowInlineStartup &&
+						(!data || !data.get("topLevelDeclarations")) &&
 						(!entryModule.buildInfo ||
 							!entryModule.buildInfo.topLevelDeclarations)
 					) {

package/lib/javascript/StartupHelpers.js

@@ -14,6 +14,7 @@ const { getAllChunks } = require("./ChunkHelpers");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGraph").EntryModuleWithChunkGroup} EntryModuleWithChunkGroup */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {(string|number)[]} EntryItem */
@@ -23,7 +24,7 @@ const EXPORT_PREFIX = "var __webpack_exports__ = ";
 /**
  * @param {ChunkGraph} chunkGraph chunkGraph
  * @param {RuntimeTemplate} runtimeTemplate runtimeTemplate
- * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
+ * @param {EntryModuleWithChunkGroup[]} entries entries
  * @param {Chunk} chunk chunk
  * @param {boolean} passive true: passive startup with on chunks loaded
  * @returns {string} runtime code
@@ -101,7 +102,7 @@ exports.generateEntryStartup = (
 /**
  * @param {Hash} hash the hash to update
  * @param {ChunkGraph} chunkGraph chunkGraph
- * @param {import("../ChunkGraph").EntryModuleWithChunkGroup[]} entries entries
+ * @param {EntryModuleWithChunkGroup[]} entries entries
  * @param {Chunk} chunk chunk
  * @returns {void}
  */

package/lib/library/AssignLibraryPlugin.js

@@ -222,9 +222,15 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 	 * @param {LibraryContext<T>} libraryContext context
 	 * @returns {string | undefined} bailout reason
 	 */
-	embedInRuntimeBailout(module, { chunk }, { options, compilation }) {
+	embedInRuntimeBailout(
+		module,
+		{ chunk, codeGenerationResults },
+		{ options, compilation }
+	) {
+		const { data } = codeGenerationResults.get(module, chunk.runtime);
 		const topLevelDeclarations =
-			module.buildInfo && module.buildInfo.topLevelDeclarations;
+			(data && data.get("topLevelDeclarations")) ||
+			(module.buildInfo && module.buildInfo.topLevelDeclarations);
 		if (!topLevelDeclarations)
 			return "it doesn't tell about top level declarations.";
 		const fullNameResolved = this._getResolvedFullName(

package/lib/node/NodeTargetPlugin.js

@@ -54,6 +54,7 @@ const builtins = [
 	"tty",
 	"url",
 	"util",
+	"util/types",
 	"v8",
 	"vm",
 	"wasi",

package/lib/optimize/ConcatenatedModule.js

@@ -822,10 +822,6 @@ class ConcatenatedModule extends Module {
 				const topLevelDeclarations = this.buildInfo.topLevelDeclarations;
 				if (topLevelDeclarations !== undefined) {
 					for (const decl of m.buildInfo.topLevelDeclarations) {
-						// reserved names will always be renamed
-						if (RESERVED_NAMES.has(decl)) continue;
-						// TODO actually this is incorrect since with renaming there could be more
-						// We should do the renaming during build
 						topLevelDeclarations.add(decl);
 					}
 				}
@@ -1113,6 +1109,8 @@ class ConcatenatedModule extends Module {
 
 		// List of all used names to avoid conflicts
 		const allUsedNames = new Set(RESERVED_NAMES);
+		// Updated Top level declarations are created by renaming
+		const topLevelDeclarations = new Set();
 
 		// List of additional names in scope for module references
 		/** @type {Map<string, { usedNames: Set<string>, alreadyCheckedScopes: Set<TODO> }>} */
@@ -1257,6 +1255,7 @@ class ConcatenatedModule extends Module {
 							);
 							allUsedNames.add(newName);
 							info.internalNames.set(name, newName);
+							topLevelDeclarations.add(newName);
 							const source = info.source;
 							const allIdentifiers = new Set(
 								references.map(r => r.identifier).concat(variable.identifiers)
@@ -1283,6 +1282,7 @@ class ConcatenatedModule extends Module {
 						} else {
 							allUsedNames.add(name);
 							info.internalNames.set(name, name);
+							topLevelDeclarations.add(name);
 						}
 					}
 					let namespaceObjectName;
@@ -1300,6 +1300,7 @@ class ConcatenatedModule extends Module {
 						allUsedNames.add(namespaceObjectName);
 					}
 					info.namespaceObjectName = namespaceObjectName;
+					topLevelDeclarations.add(namespaceObjectName);
 					break;
 				}
 				case "external": {
@@ -1311,6 +1312,7 @@ class ConcatenatedModule extends Module {
 					);
 					allUsedNames.add(externalName);
 					info.name = externalName;
+					topLevelDeclarations.add(externalName);
 					break;
 				}
 			}
@@ -1323,6 +1325,7 @@ class ConcatenatedModule extends Module {
 				);
 				allUsedNames.add(externalNameInterop);
 				info.interopNamespaceObjectName = externalNameInterop;
+				topLevelDeclarations.add(externalNameInterop);
 			}
 			if (
 				info.module.buildMeta.exportsType === "default" &&
@@ -1336,6 +1339,7 @@ class ConcatenatedModule extends Module {
 				);
 				allUsedNames.add(externalNameInterop);
 				info.interopNamespaceObject2Name = externalNameInterop;
+				topLevelDeclarations.add(externalNameInterop);
 			}
 			if (
 				info.module.buildMeta.exportsType === "dynamic" ||
@@ -1349,6 +1353,7 @@ class ConcatenatedModule extends Module {
 				);
 				allUsedNames.add(externalNameInterop);
 				info.interopDefaultAccessName = externalNameInterop;
+				topLevelDeclarations.add(externalNameInterop);
 			}
 		}
 
@@ -1618,6 +1623,7 @@ ${defineGetters}`
 		const data = new Map();
 		if (chunkInitFragments.length > 0)
 			data.set("chunkInitFragments", chunkInitFragments);
+		data.set("topLevelDeclarations", topLevelDeclarations);
 
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
@@ -1708,7 +1714,7 @@ ${defineGetters}`
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
 			} catch (err) {
-				err.message += `\nwhile analysing module ${m.identifier()} for concatenation`;
+				err.message += `\nwhile analyzing module ${m.identifier()} for concatenation`;
 				throw err;
 			}
 		}

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -22,6 +22,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 		return Template.asString([
 			'var webpackThen = typeof Symbol === "function" ? Symbol("webpack then") : "__webpack_then__";',
 			'var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "__webpack_exports__";',
+			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
 			`var completeQueue = ${runtimeTemplate.basicFunction("queue", [
 				"if(queue) {",
 				Template.indent([
@@ -56,9 +57,13 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"obj[webpackExports] = r;",
 								"completeQueue(queue);",
 								"queue = 0;"
+							])}, ${runtimeTemplate.basicFunction("e", [
+								"obj[webpackError] = e;",
+								"completeQueue(queue);",
+								"queue = 0;"
 							])});`,
-							`var obj = {};
-							obj[webpackThen] = ${runtimeTemplate.expressionFunction(
+							"var obj = {};",
+							`obj[webpackThen] = ${runtimeTemplate.expressionFunction(
 								"queueFunction(queue, fn), dep['catch'](reject)",
 								"fn, reject"
 							)};`,
@@ -67,13 +72,13 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 						"}"
 					]),
 					"}",
-					`var ret = {};
-					ret[webpackThen] = ${runtimeTemplate.expressionFunction(
+					"var ret = {};",
+					`ret[webpackThen] = ${runtimeTemplate.expressionFunction(
 						"completeFunction(fn)",
 						"fn"
-					)};
-					ret[webpackExports] = dep;
-					return ret;`
+					)};`,
+					"ret[webpackExports] = dep;",
+					"return ret;"
 				])})`,
 				"deps"
 			)};`,
@@ -119,24 +124,29 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				)};`,
 				"module.exports = promise;",
 				`body(${runtimeTemplate.basicFunction("deps", [
-					"if(!deps) return outerResolve();",
 					"currentDeps = wrapDeps(deps);",
-					"var fn, result;",
+					"var fn;",
+					`var getResult = ${runtimeTemplate.returningFunction(
+						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+							"if(d[webpackError]) throw d[webpackError];",
+							"return d[webpackExports];"
+						])})`
+					)}`,
 					`var promise = new Promise(${runtimeTemplate.basicFunction(
 						"resolve, reject",
 						[
 							`fn = ${runtimeTemplate.expressionFunction(
-								`resolve(result = currentDeps.map(${runtimeTemplate.returningFunction(
-									"d[webpackExports]",
-									"d"
-								)}))`
+								"resolve(getResult)"
 							)};`,
 							"fn.r = 0;",
 							"whenAll(currentDeps, fn, reject);"
 						]
 					)});`,
-					"return fn.r ? promise : result;"
-				])}).then(outerResolve, reject);`,
+					"return fn.r ? promise : getResult();"
+				])}, ${runtimeTemplate.expressionFunction(
+					"err && reject(promise[webpackError] = err), outerResolve()",
+					"err"
+				)});`,
 				"isEvaluating = false;"
 			])};`
 		]);

package/lib/runtime/CreateScriptRuntimeModule.js

@@ -0,0 +1,36 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+class CreateScriptRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("trusted types script");
+	}
+
+	/**
+	 * @returns {string} runtime code
+	 */
+	generate() {
+		const { compilation } = this;
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.createScript;
+
+		return Template.asString(
+			`${fn} = ${runtimeTemplate.returningFunction(
+				trustedTypes
+					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScript(script)`
+					: "script",
+				"script"
+			)};`
+		);
+	}
+}
+
+module.exports = CreateScriptRuntimeModule;