webpack 5.69.0 → 5.71.0

package/hot/poll.js

@@ -4,7 +4,7 @@
 */
 /*globals __resourceQuery */
 if (module.hot) {
-	var hotPollInterval = +__resourceQuery.substr(1) || 10 * 60 * 1000;
+	var hotPollInterval = +__resourceQuery.slice(1) || 10 * 60 * 1000;
 	var log = require("./log");
 
 	var checkForUpdate = function checkForUpdate(fromUpdate) {

package/hot/signal.js

@@ -45,7 +45,7 @@ if (module.hot) {
 			});
 	};
 
-	process.on(__resourceQuery.substr(1) || "SIGUSR2", function () {
+	process.on(__resourceQuery.slice(1) || "SIGUSR2", function () {
 		if (module.hot.status() !== "idle") {
 			log(
 				"warning",

package/lib/BannerPlugin.js

@@ -77,6 +77,7 @@ class BannerPlugin {
 			undefined,
 			options
 		);
+		const cache = new WeakMap();
 
 		compiler.hooks.compilation.tap("BannerPlugin", compilation => {
 			compilation.hooks.processAssets.tap(
@@ -102,10 +103,15 @@ class BannerPlugin {
 
 							const comment = compilation.getPath(banner, data);
 
-							compilation.updateAsset(
-								file,
-								old => new ConcatSource(comment, "\n", old)
-							);
+							compilation.updateAsset(file, old => {
+								let cached = cache.get(old);
+								if (!cached || cached.comment !== comment) {
+									const source = new ConcatSource(comment, "\n", old);
+									cache.set(old, { source, comment });
+									return source;
+								}
+								return cached.source;
+							});
 						}
 					}
 				}

package/lib/Chunk.js

@@ -690,7 +690,7 @@ class Chunk {
 				for (const childGroup of group.childrenIterable) {
 					for (const key of Object.keys(childGroup.options)) {
 						if (key.endsWith("Order")) {
-							const name = key.substr(0, key.length - "Order".length);
+							const name = key.slice(0, key.length - "Order".length);
 							let list = lists.get(name);
 							if (list === undefined) {
 								list = [];

package/lib/ChunkGroup.js

@@ -486,7 +486,7 @@ class ChunkGroup {
 		for (const childGroup of this._children) {
 			for (const key of Object.keys(childGroup.options)) {
 				if (key.endsWith("Order")) {
-					const name = key.substr(0, key.length - "Order".length);
+					const name = key.slice(0, key.length - "Order".length);
 					let list = lists.get(name);
 					if (list === undefined) {
 						lists.set(name, (list = []));

package/lib/CleanPlugin.js

@@ -19,6 +19,7 @@ const processAsyncTree = require("./util/processAsyncTree");
 /** @typedef {import("./util/fs").StatsCallback} StatsCallback */
 
 /** @typedef {(function(string):boolean)|RegExp} IgnoreItem */
+/** @typedef {Map<string, number>} Assets */
 /** @typedef {function(IgnoreItem): void} AddToIgnoreCallback */
 
 /**
@@ -40,18 +41,32 @@ const validate = createSchemaValidation(
 		baseDataPath: "options"
 	}
 );
+const _10sec = 10 * 1000;
+
+/**
+ * marge assets map 2 into map 1
+ * @param {Assets} as1 assets
+ * @param {Assets} as2 assets
+ * @returns {void}
+ */
+const mergeAssets = (as1, as2) => {
+	for (const [key, value1] of as2) {
+		const value2 = as1.get(key);
+		if (!value2 || value1 > value2) as1.set(key, value1);
+	}
+};
 
 /**
  * @param {OutputFileSystem} fs filesystem
  * @param {string} outputPath output path
- * @param {Set<string>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
+ * @param {Map<string, number>} currentAssets filename of the current assets (must not start with .. or ., must only use / as path separator)
  * @param {function((Error | null)=, Set<string>=): void} callback returns the filenames of the assets that shouldn't be there
  * @returns {void}
  */
 const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 	const directories = new Set();
 	// get directories of assets
-	for (const asset of currentAssets) {
+	for (const [asset] of currentAssets) {
 		directories.add(asset.replace(/(^|\/)[^/]*$/, ""));
 	}
 	// and all parent directories
@@ -91,13 +106,15 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
 };
 
 /**
- * @param {Set<string>} currentAssets assets list
- * @param {Set<string>} oldAssets old assets list
+ * @param {Assets} currentAssets assets list
+ * @param {Assets} oldAssets old assets list
  * @returns {Set<string>} diff
  */
 const getDiffToOldAssets = (currentAssets, oldAssets) => {
 	const diff = new Set();
-	for (const asset of oldAssets) {
+	const now = Date.now();
+	for (const [asset, ts] of oldAssets) {
+		if (ts >= now) continue;
 		if (!currentAssets.has(asset)) diff.add(asset);
 	}
 	return diff;
@@ -124,7 +141,7 @@ const doStat = (fs, filename, callback) => {
  * @param {Logger} logger logger
  * @param {Set<string>} diff filenames of the assets that shouldn't be there
  * @param {function(string): boolean} isKept check if the entry is ignored
- * @param {function(Error=): void} callback callback
+ * @param {function(Error=, Assets=): void} callback callback
  * @returns {void}
  */
 const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
@@ -137,11 +154,13 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 	};
 	/** @typedef {{ type: "check" | "unlink" | "rmdir", filename: string, parent: { remaining: number, job: Job } | undefined }} Job */
 	/** @type {Job[]} */
-	const jobs = Array.from(diff, filename => ({
+	const jobs = Array.from(diff.keys(), filename => ({
 		type: "check",
 		filename,
 		parent: undefined
 	}));
+	/** @type {Assets} */
+	const keptAssets = new Map();
 	processAsyncTree(
 		jobs,
 		10,
@@ -161,6 +180,7 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 			switch (type) {
 				case "check":
 					if (isKept(filename)) {
+						keptAssets.set(filename, 0);
 						// do not decrement parent entry as we don't want to delete the parent
 						log(`${filename} will be kept`);
 						return process.nextTick(callback);
@@ -247,7 +267,10 @@ const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
 					break;
 			}
 		},
-		callback
+		err => {
+			if (err) return callback(err);
+			callback(undefined, keptAssets);
+		}
 	);
 };
 
@@ -302,6 +325,7 @@ class CleanPlugin {
 		// We assume that no external modification happens while the compiler is active
 		// So we can store the old assets and only diff to them to avoid fs access on
 		// incremental builds
+		/** @type {undefined|Assets} */
 		let oldAssets;
 
 		compiler.hooks.emit.tapAsync(
@@ -322,7 +346,9 @@ class CleanPlugin {
 					);
 				}
 
-				const currentAssets = new Set();
+				/** @type {Assets} */
+				const currentAssets = new Map();
+				const now = Date.now();
 				for (const asset of Object.keys(compilation.assets)) {
 					if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset)) continue;
 					let normalizedAsset;
@@ -335,7 +361,12 @@ class CleanPlugin {
 						);
 					} while (newNormalizedAsset !== normalizedAsset);
 					if (normalizedAsset.startsWith("../")) continue;
-					currentAssets.add(normalizedAsset);
+					const assetInfo = compilation.assetsInfo.get(asset);
+					if (assetInfo && assetInfo.hotModuleReplacement) {
+						currentAssets.set(normalizedAsset, now + _10sec);
+					} else {
+						currentAssets.set(normalizedAsset, 0);
+					}
 				}
 
 				const outputPath = compilation.getPath(compiler.outputPath, {});
@@ -346,19 +377,34 @@ class CleanPlugin {
 					return keepFn(path);
 				};
 
+				/**
+				 * @param {Error=} err err
+				 * @param {Set<string>=} diff diff
+				 */
 				const diffCallback = (err, diff) => {
 					if (err) {
 						oldAssets = undefined;
-						return callback(err);
+						callback(err);
+						return;
 					}
-					applyDiff(fs, outputPath, dry, logger, diff, isKept, err => {
-						if (err) {
-							oldAssets = undefined;
-						} else {
-							oldAssets = currentAssets;
+					applyDiff(
+						fs,
+						outputPath,
+						dry,
+						logger,
+						diff,
+						isKept,
+						(err, keptAssets) => {
+							if (err) {
+								oldAssets = undefined;
+							} else {
+								if (oldAssets) mergeAssets(currentAssets, oldAssets);
+								oldAssets = currentAssets;
+								if (keptAssets) mergeAssets(oldAssets, keptAssets);
+							}
+							callback(err);
 						}
-						callback(err);
-					});
+					);
 				};
 
 				if (oldAssets) {

package/lib/Compilation.js

@@ -43,6 +43,7 @@ const Module = require("./Module");
 const ModuleDependencyError = require("./ModuleDependencyError");
 const ModuleDependencyWarning = require("./ModuleDependencyWarning");
 const ModuleGraph = require("./ModuleGraph");
+const ModuleHashingError = require("./ModuleHashingError");
 const ModuleNotFoundError = require("./ModuleNotFoundError");
 const ModuleProfile = require("./ModuleProfile");
 const ModuleRestoreError = require("./ModuleRestoreError");
@@ -1435,7 +1436,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void}
 	 */
 	_processModuleDependencies(module, callback) {
-		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], originModule: Module|null}>} */
+		/** @type {Array<{factory: ModuleFactory, dependencies: Dependency[], context: string|undefined, originModule: Module|null}>} */
 		const sortedDependencies = [];
 
 		/** @type {DependenciesBlock} */
@@ -1667,6 +1668,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					sortedDependencies.push({
 						factory: factoryCacheKey2,
 						dependencies: list,
+						context: dep.getContext(),
 						originModule: module
 					});
 				}
@@ -3327,7 +3329,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						dependencyTemplates,
 						runtimeTemplate,
 						runtime,
-						codeGenerationResults: results
+						codeGenerationResults: results,
+						compilation: this
 					});
 				} catch (err) {
 					errors.push(new CodeGenerationError(module, err));
@@ -3883,6 +3886,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		let statModulesFromCache = 0;
 		const { chunkGraph, runtimeTemplate, moduleMemCaches2 } = this;
 		const { hashFunction, hashDigest, hashDigestLength } = this.outputOptions;
+		const errors = [];
 		for (const module of this.modules) {
 			const memCache = moduleMemCaches2 && moduleMemCaches2.get(module);
 			for (const runtime of chunkGraph.getModuleRuntimes(module)) {
@@ -3893,7 +3897,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 							module,
 							runtime,
 							digest,
-							digest.substr(0, hashDigestLength)
+							digest.slice(0, hashDigestLength)
 						);
 						statModulesFromCache++;
 						continue;
@@ -3907,13 +3911,20 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					hashFunction,
 					runtimeTemplate,
 					hashDigest,
-					hashDigestLength
+					hashDigestLength,
+					errors
 				);
 				if (memCache) {
 					memCache.set(`moduleHash-${getRuntimeKey(runtime)}`, digest);
 				}
 			}
 		}
+		if (errors.length > 0) {
+			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+			for (const error of errors) {
+				this.errors.push(error);
+			}
+		}
 		this.logger.log(
 			`${statModulesHashed} modules hashed, ${statModulesFromCache} from cache (${
 				Math.round(
@@ -3930,22 +3941,27 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		hashFunction,
 		runtimeTemplate,
 		hashDigest,
-		hashDigestLength
+		hashDigestLength,
+		errors
 	) {
-		const moduleHash = createHash(hashFunction);
-		module.updateHash(moduleHash, {
-			chunkGraph,
-			runtime,
-			runtimeTemplate
-		});
-		const moduleHashDigest = /** @type {string} */ (
-			moduleHash.digest(hashDigest)
-		);
+		let moduleHashDigest;
+		try {
+			const moduleHash = createHash(hashFunction);
+			module.updateHash(moduleHash, {
+				chunkGraph,
+				runtime,
+				runtimeTemplate
+			});
+			moduleHashDigest = /** @type {string} */ (moduleHash.digest(hashDigest));
+		} catch (err) {
+			errors.push(new ModuleHashingError(module, err));
+			moduleHashDigest = "XXXXXX";
+		}
 		chunkGraph.setModuleHashes(
 			module,
 			runtime,
 			moduleHashDigest,
-			moduleHashDigest.substr(0, hashDigestLength)
+			moduleHashDigest.slice(0, hashDigestLength)
 		);
 		return moduleHashDigest;
 	}
@@ -4091,6 +4107,7 @@ This prevents using hashes of each other and should be avoided.`);
 		const codeGenerationJobs = [];
 		/** @type {Map<string, Map<Module, {module: Module, hash: string, runtime: RuntimeSpec, runtimes: RuntimeSpec[]}>>} */
 		const codeGenerationJobsMap = new Map();
+		const errors = [];
 
 		const processChunk = chunk => {
 			// Last minute module hash generation for modules that depend on chunk hashes
@@ -4105,7 +4122,8 @@ This prevents using hashes of each other and should be avoided.`);
 						hashFunction,
 						runtimeTemplate,
 						hashDigest,
-						hashDigestLength
+						hashDigestLength,
+						errors
 					);
 					let hashMap = codeGenerationJobsMap.get(hash);
 					if (hashMap) {
@@ -4129,9 +4147,9 @@ This prevents using hashes of each other and should be avoided.`);
 				}
 			}
 			this.logger.timeAggregate("hashing: hash runtime modules");
-			this.logger.time("hashing: hash chunks");
-			const chunkHash = createHash(hashFunction);
 			try {
+				this.logger.time("hashing: hash chunks");
+				const chunkHash = createHash(hashFunction);
 				if (outputOptions.hashSalt) {
 					chunkHash.update(outputOptions.hashSalt);
 				}
@@ -4147,7 +4165,7 @@ This prevents using hashes of each other and should be avoided.`);
 				);
 				hash.update(chunkHashDigest);
 				chunk.hash = chunkHashDigest;
-				chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+				chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
 				const fullHashModules =
 					chunkGraph.getChunkFullHashModulesIterable(chunk);
 				if (fullHashModules) {
@@ -4162,13 +4180,19 @@ This prevents using hashes of each other and should be avoided.`);
 		};
 		otherChunks.forEach(processChunk);
 		for (const chunk of runtimeChunks) processChunk(chunk);
+		if (errors.length > 0) {
+			errors.sort(compareSelect(err => err.module, compareModulesByIdentifier));
+			for (const error of errors) {
+				this.errors.push(error);
+			}
+		}
 
 		this.logger.timeAggregateEnd("hashing: hash runtime modules");
 		this.logger.timeAggregateEnd("hashing: hash chunks");
 		this.logger.time("hashing: hash digest");
 		this.hooks.fullHash.call(hash);
 		this.fullHash = /** @type {string} */ (hash.digest(hashDigest));
-		this.hash = this.fullHash.substr(0, hashDigestLength);
+		this.hash = this.fullHash.slice(0, hashDigestLength);
 		this.logger.timeEnd("hashing: hash digest");
 
 		this.logger.time("hashing: process full hash modules");
@@ -4188,7 +4212,7 @@ This prevents using hashes of each other and should be avoided.`);
 					module,
 					chunk.runtime,
 					moduleHashDigest,
-					moduleHashDigest.substr(0, hashDigestLength)
+					moduleHashDigest.slice(0, hashDigestLength)
 				);
 				codeGenerationJobsMap.get(oldHash).get(module).hash = moduleHashDigest;
 			}
@@ -4199,7 +4223,7 @@ This prevents using hashes of each other and should be avoided.`);
 				chunkHash.digest(hashDigest)
 			);
 			chunk.hash = chunkHashDigest;
-			chunk.renderedHash = chunk.hash.substr(0, hashDigestLength);
+			chunk.renderedHash = chunk.hash.slice(0, hashDigestLength);
 			this.hooks.contentHash.call(chunk);
 		}
 		this.logger.timeEnd("hashing: process full hash modules");
@@ -4801,6 +4825,9 @@ This prevents using hashes of each other and should be avoided.`);
 					chunkGraph.connectChunkAndModule(chunk, module);
 				}
 
+				/** @type {WebpackError[]} */
+				const errors = [];
+
 				// Hash modules
 				for (const module of modules) {
 					this._createModuleHash(
@@ -4810,15 +4837,14 @@ This prevents using hashes of each other and should be avoided.`);
 						hashFunction,
 						runtimeTemplate,
 						hashDigest,
-						hashDigestLength
+						hashDigestLength,
+						errors
 					);
 				}
 
 				const codeGenerationResults = new CodeGenerationResults(
 					this.outputOptions.hashFunction
 				);
-				/** @type {WebpackError[]} */
-				const errors = [];
 				/**
 				 * @param {Module} module the module
 				 * @param {Callback} callback callback

package/lib/Compiler.js

@@ -545,8 +545,21 @@ class Compiler {
 	 */
 	runAsChild(callback) {
 		const startTime = Date.now();
+
+		const finalCallback = (err, entries, compilation) => {
+			try {
+				callback(err, entries, compilation);
+			} catch (e) {
+				const err = new WebpackError(
+					`compiler.runAsChild callback error: ${e}`
+				);
+				err.details = e.stack;
+				this.parentCompilation.errors.push(err);
+			}
+		};
+
 		this.compile((err, compilation) => {
-			if (err) return callback(err);
+			if (err) return finalCallback(err);
 
 			this.parentCompilation.children.push(compilation);
 			for (const { name, source, info } of compilation.getAssets()) {
@@ -561,7 +574,7 @@ class Compiler {
 			compilation.startTime = startTime;
 			compilation.endTime = Date.now();
 
-			return callback(null, entries, compilation);
+			return finalCallback(null, entries, compilation);
 		});
 	}
 
@@ -596,7 +609,7 @@ class Compiler {
 					let immutable = info.immutable;
 					const queryStringIdx = targetFile.indexOf("?");
 					if (queryStringIdx >= 0) {
-						targetFile = targetFile.substr(0, queryStringIdx);
+						targetFile = targetFile.slice(0, queryStringIdx);
 						// We may remove the hash, which is in the query string
 						// So we recheck if the file is immutable
 						// This doesn't cover all cases, but immutable is only a performance optimization anyway

package/lib/ConstPlugin.js

@@ -324,7 +324,7 @@ class ConstPlugin {
 								}
 							} else if (expression.operator === "??") {
 								const param = parser.evaluateExpression(expression.left);
-								const keepRight = param && param.asNullish();
+								const keepRight = param.asNullish();
 								if (typeof keepRight === "boolean") {
 									// ------------------------------------------
 									//
@@ -407,7 +407,7 @@ class ConstPlugin {
 							const expression = optionalExpressionsStack.pop();
 							const evaluated = parser.evaluateExpression(expression);
 
-							if (evaluated && evaluated.asNullish()) {
+							if (evaluated.asNullish()) {
 								// ------------------------------------------
 								//
 								// Given the following code:

package/lib/ContextModule.js

@@ -19,7 +19,11 @@ const {
 	keepOriginalOrder,
 	compareModulesById
 } = require("./util/comparators");
-const { contextify, parseResource } = require("./util/identifier");
+const {
+	contextify,
+	parseResource,
+	makePathsRelative
+} = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
@@ -61,7 +65,7 @@ const makeSerializable = require("./util/makeSerializable");
 
 /**
  * @typedef {Object} ContextModuleOptionsExtras
- * @property {string|string[]} resource
+ * @property {false|string|string[]} resource
  * @property {string=} resourceQuery
  * @property {string=} resourceFragment
  * @property {TODO} resolveOptions
@@ -170,8 +174,9 @@ class ContextModule extends Module {
 	_createIdentifier() {
 		let identifier =
 			this.context ||
-			(typeof this.options.resource === "string"
-				? this.options.resource
+			(typeof this.options.resource === "string" ||
+			this.options.resource === false
+				? `${this.options.resource}`
 				: this.options.resource.join("|"));
 		if (this.options.resourceQuery) {
 			identifier += `|${this.options.resourceQuery}`;
@@ -240,8 +245,11 @@ class ContextModule extends Module {
 		let identifier;
 		if (this.context) {
 			identifier = requestShortener.shorten(this.context) + "/";
-		} else if (typeof this.options.resource === "string") {
-			identifier = requestShortener.shorten(this.options.resource) + "/";
+		} else if (
+			typeof this.options.resource === "string" ||
+			this.options.resource === false
+		) {
+			identifier = requestShortener.shorten(`${this.options.resource}`) + "/";
 		} else {
 			identifier = this.options.resource
 				.map(r => requestShortener.shorten(r) + "/")
@@ -310,14 +318,14 @@ class ContextModule extends Module {
 				this.options.resource,
 				options.associatedObjectForCache
 			);
+		} else if (this.options.resource === false) {
+			identifier = "false";
 		} else {
-			const arr = [];
-			for (const res of this.options.resource) {
-				arr.push(
+			identifier = this.options.resource
+				.map(res =>
 					contextify(options.context, res, options.associatedObjectForCache)
-				);
-			}
-			identifier = arr.join(" ");
+				)
+				.join(" ");
 		}
 
 		if (this.layer) identifier = `(${this.layer})/${identifier}`;
@@ -368,8 +376,9 @@ class ContextModule extends Module {
 		// build if enforced
 		if (this._forceBuild) return callback(null, true);
 
-		// always build when we have no snapshot
-		if (!this.buildInfo.snapshot) return callback(null, true);
+		// always build when we have no snapshot and context
+		if (!this.buildInfo.snapshot)
+			return callback(null, Boolean(this.context || this.options.resource));
 
 		fileSystemInfo.checkSnapshotValid(this.buildInfo.snapshot, (err, valid) => {
 			callback(err, !valid);
@@ -484,6 +493,8 @@ class ContextModule extends Module {
 				);
 				return;
 			}
+			if (!this.context && !this.options.resource) return callback();
+
 			compilation.fileSystemInfo.createSnapshot(
 				startTime,
 				null,
@@ -491,7 +502,7 @@ class ContextModule extends Module {
 					? [this.context]
 					: typeof this.options.resource === "string"
 					? [this.options.resource]
-					: this.options.resource,
+					: /** @type {string[]} */ (this.options.resource),
 				null,
 				SNAPSHOT_OPTIONS,
 				(err, snapshot) => {
@@ -519,6 +530,8 @@ class ContextModule extends Module {
 			contextDependencies.add(this.context);
 		} else if (typeof this.options.resource === "string") {
 			contextDependencies.add(this.options.resource);
+		} else if (this.options.resource === false) {
+			return;
 		} else {
 			for (const res of this.options.resource) contextDependencies.add(res);
 		}
@@ -1057,9 +1070,21 @@ module.exports = webpackEmptyAsyncContext;`;
 		return this.getSourceForEmptyContext(id, runtimeTemplate);
 	}
 
-	getSource(sourceString) {
+	/**
+	 * @param {string} sourceString source content
+	 * @param {Compilation=} compilation the compilation
+	 * @returns {Source} generated source
+	 */
+	getSource(sourceString, compilation) {
 		if (this.useSourceMap || this.useSimpleSourceMap) {
-			return new OriginalSource(sourceString, this.identifier());
+			return new OriginalSource(
+				sourceString,
+				`webpack://${makePathsRelative(
+					(compilation && compilation.compiler.context) || "",
+					this.identifier(),
+					compilation && compilation.compiler.root
+				)}`
+			);
 		}
 		return new RawSource(sourceString);
 	}
@@ -1069,16 +1094,23 @@ module.exports = webpackEmptyAsyncContext;`;
 	 * @returns {CodeGenerationResult} result
 	 */
 	codeGeneration(context) {
-		const { chunkGraph } = context;
+		const { chunkGraph, compilation } = context;
 		const sources = new Map();
 		sources.set(
 			"javascript",
-			this.getSource(this.getSourceString(this.options.mode, context))
+			this.getSource(
+				this.getSourceString(this.options.mode, context),
+				compilation
+			)
 		);
 		const set = new Set();
-		const allDeps = /** @type {ContextElementDependency[]} */ (
-			this.dependencies.concat(this.blocks.map(b => b.dependencies[0]))
-		);
+		const allDeps =
+			this.dependencies.length > 0
+				? /** @type {ContextElementDependency[]} */ (this.dependencies).slice()
+				: [];
+		for (const block of this.blocks)
+			for (const dep of block.dependencies)
+				allDeps.push(/** @type {ContextElementDependency} */ (dep));
 		set.add(RuntimeGlobals.module);
 		set.add(RuntimeGlobals.hasOwnProperty);
 		if (allDeps.length > 0) {