webpack 5.10.0 → 5.11.0

package/lib/Compilation.js

@@ -71,6 +71,7 @@ const {
 	createFakeHook
 } = require("./util/deprecation");
 const { getRuntimeKey } = require("./util/runtime");
+const { isSourceEqual } = require("./util/source");
 
 /** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
 /** @typedef {import("webpack-sources").Source} Source */
@@ -166,7 +167,7 @@ const { getRuntimeKey } = require("./util/runtime");
  */
 
 /**
- * @typedef {Object} AssetInfo
+ * @typedef {Object} KnownAssetInfo
  * @property {boolean=} immutable true, if the asset can be long term cached forever (contains a hash)
  * @property {boolean=} minimized whether the asset is minimized
  * @property {string | string[]=} fullhash the value(s) of the full hash used for this asset
@@ -181,6 +182,8 @@ const { getRuntimeKey } = require("./util/runtime");
  * @property {Record<string, string | string[]>=} related object of pointers to other assets, keyed by type of relation (only points from parent to child)
  */
 
+/** @typedef {KnownAssetInfo & Record<string, any>} AssetInfo */
+
 /**
  * @typedef {Object} Asset
  * @property {string} name the filename of the asset
@@ -263,25 +266,6 @@ const byLocation = compareSelect(err => err.loc, compareLocations);
 
 const compareErrors = concatComparators(byModule, byLocation, byMessage);
 
-/**
- * @param {Source} a a source
- * @param {Source} b another source
- * @returns {boolean} true, when both sources are equal
- */
-const isSourceEqual = (a, b) => {
-	if (a === b) return true;
-	// TODO webpack 5: check .buffer() instead, it's called anyway during emit
-	/** @type {Buffer|string} */
-	let aSource = a.source();
-	/** @type {Buffer|string} */
-	let bSource = b.source();
-	if (aSource === bSource) return true;
-	if (typeof aSource === "string" && typeof bSource === "string") return false;
-	if (!Buffer.isBuffer(aSource)) aSource = Buffer.from(aSource, "utf-8");
-	if (!Buffer.isBuffer(bSource)) bSource = Buffer.from(bSource, "utf-8");
-	return aSource.equals(bSource);
-};
-
 class Compilation {
 	/**
 	 * Creates an instance of Compilation.
@@ -309,7 +293,7 @@ class Compilation {
 		processAssetsHook.intercept({
 			name: "Compilation",
 			call: () => {
-				savedAssets.clear();
+				savedAssets = new Set(Object.keys(this.assets));
 			},
 			register: tap => {
 				const { type, name } = tap;

package/lib/Compiler.js

@@ -29,6 +29,7 @@ const WebpackError = require("./WebpackError");
 const { Logger } = require("./logging/Logger");
 const { join, dirname, mkdirp } = require("./util/fs");
 const { makePathsRelative } = require("./util/identifier");
+const { isSourceEqual } = require("./util/source");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/WebpackOptions").EntryNormalized} Entry */
@@ -530,6 +531,7 @@ class Compiler {
 
 			const assets = compilation.getAssets();
 			compilation.assets = { ...compilation.assets };
+			/** @type {Map<string, { path: string, source: Source, size: number, waiting: { cacheEntry: any, file: string }[] }>} */
 			const caseInsensitiveMap = new Map();
 			asyncLib.forEachLimit(
 				assets,
@@ -559,19 +561,6 @@ class Compiler {
 							targetFile
 						);
 
-						const caseInsensitiveTargetPath = targetPath.toLowerCase();
-						if (caseInsensitiveMap.has(caseInsensitiveTargetPath)) {
-							const other = caseInsensitiveMap.get(caseInsensitiveTargetPath);
-							const err = new WebpackError(`Prevent writing to file that only differs in casing or query string from already written file.
-This will lead to a race-condition and corrupted files on case-insensitive file systems.
-${targetPath}
-${other}`);
-							err.file = file;
-							return callback(err);
-						} else {
-							caseInsensitiveMap.set(caseInsensitiveTargetPath, targetPath);
-						}
-
 						// check if the target file has already been written by this Compiler
 						const targetFileGeneration = this._assetEmittingWrittenFiles.get(
 							targetPath
@@ -587,6 +576,46 @@ ${other}`);
 							this._assetEmittingSourceCache.set(source, cacheEntry);
 						}
 
+						let similarEntry;
+
+						const checkSimilarFile = () => {
+							const caseInsensitiveTargetPath = targetPath.toLowerCase();
+							similarEntry = caseInsensitiveMap.get(caseInsensitiveTargetPath);
+							if (similarEntry !== undefined) {
+								const { path: other, source: otherSource } = similarEntry;
+								if (isSourceEqual(otherSource, source)) {
+									// Size may or may not be available at this point.
+									// If it's not available add to "waiting" list and it will be updated once available
+									if (similarEntry.size !== undefined) {
+										updateWithReplacementSource(similarEntry.size);
+									} else {
+										if (!similarEntry.waiting) similarEntry.waiting = [];
+										similarEntry.waiting.push({ file, cacheEntry });
+									}
+									alreadyWritten();
+								} else {
+									const err = new WebpackError(`Prevent writing to file that only differs in casing or query string from already written file.
+This will lead to a race-condition and corrupted files on case-insensitive file systems.
+${targetPath}
+${other}`);
+									err.file = file;
+									callback(err);
+								}
+								return true;
+							} else {
+								caseInsensitiveMap.set(
+									caseInsensitiveTargetPath,
+									(similarEntry = {
+										path: targetPath,
+										source,
+										size: undefined,
+										waiting: undefined
+									})
+								);
+								return false;
+							}
+						};
+
 						/**
 						 * get the binary (Buffer) content from the Source
 						 * @returns {Buffer} content for the source
@@ -650,6 +679,20 @@ ${other}`);
 						};
 
 						const updateWithReplacementSource = size => {
+							updateFileWithReplacementSource(file, cacheEntry, size);
+							similarEntry.size = size;
+							if (similarEntry.waiting !== undefined) {
+								for (const { file, cacheEntry } of similarEntry.waiting) {
+									updateFileWithReplacementSource(file, cacheEntry, size);
+								}
+							}
+						};
+
+						const updateFileWithReplacementSource = (
+							file,
+							cacheEntry,
+							size
+						) => {
 							// Create a replacement resource which only allows to ask for size
 							// This allows to GC all memory allocated by the Source
 							// (expect when the Source is stored in any other cache)
@@ -718,6 +761,7 @@ ${other}`);
 							}
 
 							if (!immutable) {
+								if (checkSimilarFile()) return;
 								// We wrote to this file before which has very likely a different content
 								// skip comparing and assume content is different for performance
 								// This case happens often during watch mode.
@@ -725,6 +769,7 @@ ${other}`);
 							}
 						}
 
+						if (checkSimilarFile()) return;
 						if (this.options.output.compareBeforeEmit) {
 							this.outputFileSystem.stat(targetPath, (err, stats) => {
 								const exists = !err && stats.isFile();

package/lib/FlagAllModulesAsUsedPlugin.js

@@ -40,6 +40,10 @@ class FlagAllModulesAsUsedPlugin {
 							const exportsInfo = moduleGraph.getExportsInfo(module);
 							exportsInfo.setUsedInUnknownWay(runtime);
 							moduleGraph.addExtraReason(module, this.explanation);
+							if (module.factoryMeta === undefined) {
+								module.factoryMeta = {};
+							}
+							module.factoryMeta.sideEffectFree = false;
 						}
 					}
 				);

package/lib/MainTemplate.js

@@ -91,7 +91,7 @@ class MainTemplate {
 			beforeStartup: {
 				tap: () => {
 					throw new Error(
-						"MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startup instead)"
+						"MainTemplate.hooks.beforeStartup has been removed (use RuntimeGlobals.startupOnlyBefore instead)"
 					);
 				}
 			},
@@ -105,7 +105,7 @@ class MainTemplate {
 			afterStartup: {
 				tap: () => {
 					throw new Error(
-						"MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startup instead)"
+						"MainTemplate.hooks.afterStartup has been removed (use RuntimeGlobals.startupOnlyAfter instead)"
 					);
 				}
 			},

package/lib/Module.js

@@ -153,7 +153,7 @@ class Module extends DependenciesBlock {
 		this._errors = undefined;
 		/** @type {BuildMeta} */
 		this.buildMeta = undefined;
-		/** @type {object} */
+		/** @type {Record<string, any>} */
 		this.buildInfo = undefined;
 		/** @type {Dependency[] | undefined} */
 		this.presentationalDependencies = undefined;

package/lib/ModuleInfoHeaderPlugin.js

@@ -191,7 +191,7 @@ class ModuleInfoHeaderPlugin {
 						const req = module.readableIdentifier(requestShortener);
 						const reqStr = req.replace(/\*\//g, "*_/");
 						const reqStrStar = "*".repeat(reqStr.length);
-						const headerStr = `/*!****${reqStrStar}****!*\n  !*** ${reqStr} ***!\n  \\****${reqStrStar}****/\n`;
+						const headerStr = `/*!****${reqStrStar}****!*\\\n  !*** ${reqStr} ***!\n  \\****${reqStrStar}****/\n`;
 						header = new RawSource(headerStr);
 						cacheEntry.header = header;
 					}

package/lib/NormalModule.js

@@ -868,8 +868,10 @@ class NormalModule extends Module {
 	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
 	 */
 	getSideEffectsConnectionState(moduleGraph) {
-		if (this.factoryMeta !== undefined && this.factoryMeta.sideEffectFree)
-			return false;
+		if (this.factoryMeta !== undefined) {
+			if (this.factoryMeta.sideEffectFree) return false;
+			if (this.factoryMeta.sideEffectFree === false) return true;
+		}
 		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
 			if (this._isEvaluatingSideEffects)
 				return ModuleGraphConnection.CIRCULAR_CONNECTION;

package/lib/RuntimeGlobals.js

@@ -194,10 +194,20 @@ exports.getChunkUpdateScriptFilename = "__webpack_require__.hu";
 exports.startup = "__webpack_require__.x";
 
 /**
- * startup signal from runtime
+ * creating a default startup function with the entry modules
  */
 exports.startupNoDefault = "__webpack_require__.x (no default handler)";
 
+/**
+ * startup signal from runtime but only used to add logic after the startup
+ */
+exports.startupOnlyAfter = "__webpack_require__.x (only after)";
+
+/**
+ * startup signal from runtime but only used to add sync logic before the startup
+ */
+exports.startupOnlyBefore = "__webpack_require__.x (only before)";
+
 /**
  * method to startup an entrypoint with needed chunks.
  * Signature: (moduleId: Id, chunkIds: Id[]) => any.

package/lib/RuntimeModule.js

@@ -185,4 +185,24 @@ class RuntimeModule extends Module {
 	}
 }
 
+/**
+ * Runtime modules without any dependencies to other runtime modules
+ */
+RuntimeModule.STAGE_NORMAL = 0;
+
+/**
+ * Runtime modules with simple dependencies on other runtime modules
+ */
+RuntimeModule.STAGE_BASIC = 5;
+
+/**
+ * Runtime modules which attach to handlers of other runtime modules
+ */
+RuntimeModule.STAGE_ATTACH = 10;
+
+/**
+ * Runtime modules which trigger actions on bootstrap
+ */
+RuntimeModule.STAGE_TRIGGER = 20;
+
 module.exports = RuntimeModule;

package/lib/RuntimeTemplate.js

@@ -113,6 +113,10 @@ class RuntimeTemplate {
 			: `function(${args}) {\n${Template.indent(body)}\n}`;
 	}
 
+	emptyFunction() {
+		return this.supportsArrowFunction() ? "x => {}" : "function() {}";
+	}
+
 	destructureArray(items, value) {
 		return this.supportsDestructuring()
 			? `var [${items.join(", ")}] = ${value};`

package/lib/cache/PackFileCacheStrategy.js

@@ -961,10 +961,8 @@ class PackFileCacheStrategy {
 				for (const dep of this.newBuildDependencies) {
 					if (!this.buildDependencies.has(dep)) {
 						newBuildDependencies.add(dep);
-						this.buildDependencies.add(dep);
 					}
 				}
-				this.newBuildDependencies.clear();
 				if (newBuildDependencies.size > 0 || !this.buildSnapshot) {
 					if (reportProgress) reportProgress(0.5, "resolve build dependencies");
 					this.logger.debug(
@@ -1093,6 +1091,10 @@ class PackFileCacheStrategy {
 							logger: this.logger
 						})
 						.then(() => {
+							for (const dep of newBuildDependencies) {
+								this.buildDependencies.add(dep);
+							}
+							this.newBuildDependencies.clear();
 							this.logger.timeEnd(`store pack`);
 							this.logger.log(`Stored pack`);
 						})

package/lib/hmr/HotModuleReplacementRuntimeModule.js

@@ -11,7 +11,7 @@ const Template = require("../Template");
 
 class HotModuleReplacementRuntimeModule extends RuntimeModule {
 	constructor() {
-		super("hot module replacement", 5);
+		super("hot module replacement", RuntimeModule.STAGE_BASIC);
 	}
 	/**
 	 * @returns {string} runtime code

package/lib/index.js

@@ -22,6 +22,8 @@ const memorize = require("./util/memorize");
 /** @typedef {import("../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginFunction} WebpackPluginFunction */
 /** @typedef {import("../declarations/WebpackOptions").WebpackPluginInstance} WebpackPluginInstance */
+/** @typedef {import("./Compilation").Asset} Asset */
+/** @typedef {import("./Compilation").AssetInfo} AssetInfo */
 /** @typedef {import("./Parser").ParserState} ParserState */
 
 /**
@@ -260,6 +262,9 @@ module.exports = mergeExports(fn, {
 	get WatchIgnorePlugin() {
 		return require("./WatchIgnorePlugin");
 	},
+	get WebpackError() {
+		return require("./WebpackError");
+	},
 	get WebpackOptionsApply() {
 		return require("./WebpackOptionsApply");
 	},

package/lib/javascript/JavascriptModulesPlugin.js

@@ -630,6 +630,17 @@ class JavascriptModulesPlugin {
 			}
 		}
 		if (inlinedModules) {
+			if (bootstrap.beforeStartup.length > 0) {
+				const beforeStartup = Template.asString(bootstrap.beforeStartup) + "\n";
+				source.add(
+					new PrefixSource(
+						prefix,
+						useSourceMap
+							? new OriginalSource(beforeStartup, "webpack/before-startup")
+							: new RawSource(beforeStartup)
+					)
+				);
+			}
 			for (const m of inlinedModules) {
 				const renderedModule = this.renderModule(
 					m,
@@ -658,8 +669,24 @@ class JavascriptModulesPlugin {
 					}
 				}
 			}
+			if (bootstrap.afterStartup.length > 0) {
+				const afterStartup = Template.asString(bootstrap.afterStartup) + "\n";
+				source.add(
+					new PrefixSource(
+						prefix,
+						useSourceMap
+							? new OriginalSource(afterStartup, "webpack/after-startup")
+							: new RawSource(afterStartup)
+					)
+				);
+			}
 		} else {
-			const startup = Template.asString(bootstrap.startup) + "\n";
+			const startup =
+				Template.asString([
+					...bootstrap.beforeStartup,
+					...bootstrap.startup,
+					...bootstrap.afterStartup
+				]) + "\n";
 			source.add(
 				new PrefixSource(
 					prefix,
@@ -718,7 +745,7 @@ class JavascriptModulesPlugin {
 	/**
 	 * @param {RenderBootstrapContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
-	 * @returns {{ header: string[], startup: string[], allowInlineStartup: boolean }} the generated source of the bootstrap code
+	 * @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;
@@ -751,12 +778,13 @@ class JavascriptModulesPlugin {
 
 		const result = {
 			header: [],
+			beforeStartup: [],
 			startup: [],
+			afterStartup: [],
 			allowInlineStartup: true
 		};
 
-		let buf = result.header;
-		let startup = result.startup;
+		let { header: buf, startup, beforeStartup, afterStartup } = result;
 
 		if (result.allowInlineStartup && moduleFactories) {
 			startup.push(
@@ -889,40 +917,68 @@ class JavascriptModulesPlugin {
 						buf2.push(`__webpack_modules__[${moduleIdExpr}]();`);
 					}
 				}
-				if (runtimeRequirements.has(RuntimeGlobals.startup)) {
+				if (
+					runtimeRequirements.has(RuntimeGlobals.startup) ||
+					((returnExportsFromRuntime ||
+						runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) &&
+						runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter))
+				) {
 					result.allowInlineStartup = false;
+					buf.push("// the startup function");
 					buf.push(
-						Template.asString([
-							"// the startup function",
-							`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
-								"",
-								buf2
-							)};`
-						])
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
+							"",
+							buf2
+						)};`
 					);
 					buf.push("");
 					startup.push("// run startup");
 					startup.push(`return ${RuntimeGlobals.startup}();`);
-				} else {
-					startup.push(
-						Template.asString(["// startup", Template.asString(buf2)])
+				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore)) {
+					buf.push("// the startup function");
+					buf.push(
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
+					);
+					beforeStartup.push("// run runtime startup");
+					beforeStartup.push(`${RuntimeGlobals.startup}();`);
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
+				} else if (runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)) {
+					buf.push("// the startup function");
+					buf.push(
+						`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()};`
 					);
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
+					afterStartup.push("// run runtime startup");
+					afterStartup.push(`return ${RuntimeGlobals.startup}();`);
+				} else {
+					startup.push("// startup");
+					startup.push(Template.asString(buf2));
 				}
-			} else if (runtimeRequirements.has(RuntimeGlobals.startup)) {
+			} else if (
+				runtimeRequirements.has(RuntimeGlobals.startup) ||
+				runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
+				runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
+			) {
 				buf.push(
-					Template.asString([
-						"// the startup function",
-						"// It's empty as no entry modules are in this chunk",
-						`${RuntimeGlobals.startup} = ${runtimeTemplate.basicFunction(
-							"",
-							""
-						)}`
-					])
+					"// the startup function",
+					"// It's empty as no entry modules are in this chunk",
+					`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()}`,
+					""
 				);
-				buf.push("");
 			}
-		} else if (runtimeRequirements.has(RuntimeGlobals.startup)) {
+		} else if (
+			runtimeRequirements.has(RuntimeGlobals.startup) ||
+			runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) ||
+			runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
+		) {
 			result.allowInlineStartup = false;
+			buf.push(
+				"// the startup function",
+				"// It's empty as some runtime module handles the default behavior",
+				`${RuntimeGlobals.startup} = ${runtimeTemplate.emptyFunction()}`
+			);
 			startup.push("// run startup");
 			startup.push(`return ${RuntimeGlobals.startup}();`);
 		}

package/lib/node/NodeTargetPlugin.js

@@ -20,6 +20,7 @@ const builtins = [
 	"crypto",
 	"dgram",
 	"dns",
+	"dns/promises",
 	"domain",
 	"events",
 	"fs",
@@ -39,9 +40,11 @@ const builtins = [
 	"readline",
 	"repl",
 	"stream",
+	"stream/promises",
 	"string_decoder",
 	"sys",
 	"timers",
+	"timers/promises",
 	"tls",
 	"trace_events",
 	"tty",
@@ -49,6 +52,7 @@ const builtins = [
 	"util",
 	"v8",
 	"vm",
+	"wasi", // cSpell:ignore wasi
 	"worker_threads",
 	"zlib"
 ];

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -16,7 +16,7 @@ const { getUndoPath } = require("../util/identifier");
 
 class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 	constructor(runtimeRequirements) {
-		super("readFile chunk loading", 10);
+		super("readFile chunk loading", RuntimeModule.STAGE_ATTACH);
 		this.runtimeRequirements = runtimeRequirements;
 	}
 

package/lib/node/RequireChunkLoadingRuntimeModule.js

@@ -16,7 +16,7 @@ const { getUndoPath } = require("../util/identifier");
 
 class RequireChunkLoadingRuntimeModule extends RuntimeModule {
 	constructor(runtimeRequirements) {
-		super("require chunk loading", 10);
+		super("require chunk loading", RuntimeModule.STAGE_ATTACH);
 		this.runtimeRequirements = runtimeRequirements;
 	}
 

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -82,16 +82,16 @@ class SideEffectsFlagPlugin {
 							resolveData.relativePath
 						) {
 							const sideEffects = resolveData.descriptionFileData.sideEffects;
-							const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
-								resolveData.relativePath,
-								sideEffects,
-								cache
-							);
-							if (!hasSideEffects) {
+							if (sideEffects !== undefined) {
 								if (module.factoryMeta === undefined) {
 									module.factoryMeta = {};
 								}
-								module.factoryMeta.sideEffectFree = true;
+								const hasSideEffects = SideEffectsFlagPlugin.moduleHasSideEffects(
+									resolveData.relativePath,
+									sideEffects,
+									cache
+								);
+								module.factoryMeta.sideEffectFree = !hasSideEffects;
 							}
 						}
 
@@ -101,15 +101,11 @@ class SideEffectsFlagPlugin {
 				normalModuleFactory.hooks.module.tap(
 					"SideEffectsFlagPlugin",
 					(module, data) => {
-						if (data.settings.sideEffects === false) {
+						if (typeof data.settings.sideEffects === "boolean") {
 							if (module.factoryMeta === undefined) {
 								module.factoryMeta = {};
 							}
-							module.factoryMeta.sideEffectFree = true;
-						} else if (data.settings.sideEffects === true) {
-							if (module.factoryMeta !== undefined) {
-								module.factoryMeta.sideEffectFree = false;
-							}
+							module.factoryMeta.sideEffectFree = !data.settings.sideEffects;
 						}
 						return module;
 					}

package/lib/prefetch/ChunkPrefetchFunctionRuntimeModule.js

@@ -16,7 +16,7 @@ class ChunkPrefetchFunctionRuntimeModule extends RuntimeModule {
 	 * @param {string} runtimeHandlers TODO
 	 */
 	constructor(childType, runtimeFunction, runtimeHandlers) {
-		super(`chunk ${childType} function`, 5);
+		super(`chunk ${childType} function`);
 		this.childType = childType;
 		this.runtimeFunction = runtimeFunction;
 		this.runtimeHandlers = runtimeHandlers;

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -29,7 +29,7 @@ class ChunkPrefetchPreloadPlugin {
 						const startupChildChunks = chunk.getChildIdsByOrders(chunkGraph);
 						if (startupChildChunks.prefetch) {
 							set.add(RuntimeGlobals.prefetchChunk);
-							set.add(RuntimeGlobals.startup);
+							set.add(RuntimeGlobals.startupOnlyAfter);
 							compilation.addRuntimeModule(
 								chunk,
 								new ChunkPrefetchStartupRuntimeModule(

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -17,7 +17,7 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 	 * @param {(string|number)[]} startupChunks chunk ids to trigger after startup
 	 */
 	constructor(childType, runtimeFunction, startupChunks) {
-		super(`startup ${childType}`, 5);
+		super(`startup ${childType}`, RuntimeModule.STAGE_TRIGGER);
 		this.childType = childType;
 		this.runtimeFunction = runtimeFunction;
 		this.startupChunks = startupChunks;

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -18,7 +18,7 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 	 * @param {boolean} afterChunkLoad true: start after chunk has been loaded, false: start after chunk loading has started
 	 */
 	constructor(childType, runtimeFunction, chunkMap, afterChunkLoad) {
-		super(`chunk ${childType} trigger`, 20);
+		super(`chunk ${childType} trigger`, RuntimeModule.STAGE_TRIGGER);
 		this.childType = childType;
 		this.runtimeFunction = runtimeFunction;
 		this.chunkMap = chunkMap;

package/lib/rules/RuleSetCompiler.js

@@ -96,8 +96,10 @@ class RuleSetCompiler {
 					}
 				} else if (p in data) {
 					const value = data[p];
-					if (!condition.fn(value)) return false;
-					continue;
+					if (value !== undefined) {
+						if (!condition.fn(value)) return false;
+						continue;
+					}
 				}
 				if (!condition.matchWhenEmpty) {
 					return false;

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -12,7 +12,7 @@ const { getUndoPath } = require("../util/identifier");
 
 class AutoPublicPathRuntimeModule extends RuntimeModule {
 	constructor() {
-		super("publicPath", 5);
+		super("publicPath", RuntimeModule.STAGE_BASIC);
 	}
 
 	/**