webpack 5.14.0 → 5.18.0

package/lib/HotModuleReplacementPlugin.js

@@ -39,6 +39,7 @@ const {
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
+/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /**
  * @typedef {Object} HMRJavascriptParserHooks
@@ -316,37 +317,61 @@ class HotModuleReplacementPlugin {
 				/** @type {TupleSet<[Module, Chunk]>} */
 				const updatedModules = new TupleSet();
 				/** @type {TupleSet<[Module, Chunk]>} */
-				const lazyHashedModules = new TupleSet();
+				const fullHashModules = new TupleSet();
+				/** @type {TupleSet<[Module, RuntimeSpec]>} */
+				const nonCodeGeneratedModules = new TupleSet();
 				compilation.hooks.fullHash.tap("HotModuleReplacementPlugin", hash => {
 					const chunkGraph = compilation.chunkGraph;
 					const records = compilation.records;
 					for (const chunk of compilation.chunks) {
-						/** @type {Set<Module>} */
-						const lazyHashedModulesInThisChunk = new Set();
-						const fullHashModules = chunkGraph.getChunkFullHashModulesIterable(
+						const getModuleHash = module => {
+							if (
+								compilation.codeGenerationResults.has(module, chunk.runtime)
+							) {
+								return compilation.codeGenerationResults.getHash(
+									module,
+									chunk.runtime
+								);
+							} else {
+								nonCodeGeneratedModules.add(module, chunk.runtime);
+								return chunkGraph.getModuleHash(module, chunk.runtime);
+							}
+						};
+						const fullHashModulesInThisChunk = chunkGraph.getChunkFullHashModulesSet(
 							chunk
 						);
-						if (fullHashModules !== undefined) {
-							for (const module of fullHashModules) {
-								lazyHashedModules.add(module, chunk);
-								lazyHashedModulesInThisChunk.add(module);
+						if (fullHashModulesInThisChunk !== undefined) {
+							for (const module of fullHashModulesInThisChunk) {
+								fullHashModules.add(module, chunk);
 							}
 						}
 						const modules = chunkGraph.getChunkModulesIterable(chunk);
 						if (modules !== undefined) {
-							if (
-								records.chunkModuleHashes &&
-								records.fullHashChunkModuleHashes
-							) {
-								for (const module of modules) {
-									const key = `${chunk.id}|${module.identifier()}`;
-									const hash = chunkGraph.getModuleHash(module, chunk.runtime);
-									if (lazyHashedModulesInThisChunk.has(module)) {
-										if (records.fullHashChunkModuleHashes[key] !== hash) {
-											updatedModules.add(module, chunk);
+							if (records.chunkModuleHashes) {
+								if (fullHashModulesInThisChunk !== undefined) {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (
+											fullHashModulesInThisChunk.has(
+												/** @type {RuntimeModule} */ (module)
+											)
+										) {
+											if (records.fullHashChunkModuleHashes[key] !== hash) {
+												updatedModules.add(module, chunk);
+											}
+											fullHashChunkModuleHashes[key] = hash;
+										} else {
+											if (records.chunkModuleHashes[key] !== hash) {
+												updatedModules.add(module, chunk);
+											}
+											chunkModuleHashes[key] = hash;
 										}
-										fullHashChunkModuleHashes[key] = hash;
-									} else {
+									}
+								} else {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
 										if (records.chunkModuleHashes[key] !== hash) {
 											updatedModules.add(module, chunk);
 										}
@@ -354,12 +379,24 @@ class HotModuleReplacementPlugin {
 									}
 								}
 							} else {
-								for (const module of modules) {
-									const key = `${chunk.id}|${module.identifier()}`;
-									const hash = chunkGraph.getModuleHash(module, chunk.runtime);
-									if (lazyHashedModulesInThisChunk.has(module)) {
-										fullHashChunkModuleHashes[key] = hash;
-									} else {
+								if (fullHashModulesInThisChunk !== undefined) {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
+										if (
+											fullHashModulesInThisChunk.has(
+												/** @type {RuntimeModule} */ (module)
+											)
+										) {
+											fullHashChunkModuleHashes[key] = hash;
+										} else {
+											chunkModuleHashes[key] = hash;
+										}
+									}
+								} else {
+									for (const module of modules) {
+										const key = `${chunk.id}|${module.identifier()}`;
+										const hash = getModuleHash(module);
 										chunkModuleHashes[key] = hash;
 									}
 								}
@@ -388,9 +425,14 @@ class HotModuleReplacementPlugin {
 						) {
 							return;
 						}
-						for (const [module, chunk] of lazyHashedModules) {
+						for (const [module, chunk] of fullHashModules) {
 							const key = `${chunk.id}|${module.identifier()}`;
-							const hash = chunkGraph.getModuleHash(module, chunk.runtime);
+							const hash = nonCodeGeneratedModules.has(module, chunk.runtime)
+								? chunkGraph.getModuleHash(module, chunk.runtime)
+								: compilation.codeGenerationResults.getHash(
+										module,
+										chunk.runtime
+								  );
 							if (records.chunkModuleHashes[key] !== hash) {
 								updatedModules.add(module, chunk);
 							}
@@ -500,7 +542,12 @@ class HotModuleReplacementPlugin {
 									const runtimes = chunkGraph.getModuleRuntimes(module);
 									if (oldRuntime === newRuntime && runtimes.has(newRuntime)) {
 										// Module is still in the same runtime combination
-										const hash = chunkGraph.getModuleHash(module, newRuntime);
+										const hash = nonCodeGeneratedModules.has(module, newRuntime)
+											? chunkGraph.getModuleHash(module, newRuntime)
+											: compilation.codeGenerationResults.getHash(
+													module,
+													newRuntime
+											  );
 										if (hash !== oldHash) {
 											if (module.type === "runtime") {
 												newRuntimeModules = newRuntimeModules || [];

package/lib/IgnoreErrorModuleFactory.js

@@ -0,0 +1,39 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const ModuleFactory = require("./ModuleFactory");
+
+/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
+/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
+/** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
+
+/**
+ * Ignores error when module is unresolved
+ */
+class IgnoreErrorModuleFactory extends ModuleFactory {
+	/**
+	 * @param {NormalModuleFactory} normalModuleFactory normalModuleFactory instance
+	 */
+	constructor(normalModuleFactory) {
+		super();
+
+		this.normalModuleFactory = normalModuleFactory;
+	}
+
+	/**
+	 * @param {ModuleFactoryCreateData} data data object
+	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @returns {void}
+	 */
+	create(data, callback) {
+		this.normalModuleFactory.create(data, (err, result) => {
+			return callback(null, result);
+		});
+	}
+}
+
+module.exports = IgnoreErrorModuleFactory;

package/lib/Module.js

@@ -67,6 +67,7 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {Map<string, Source>} sources the resulting sources for all source types
  * @property {Map<string, any>=} data the resulting data for all source types
  * @property {ReadonlySet<string>} runtimeRequirements the runtime requirements
+ * @property {string=} hash a hash of the code generation result (will be automatically calculated from sources and runtimeRequirements if not provided)
  */
 
 /**
@@ -703,9 +704,7 @@ class Module extends DependenciesBlock {
 		}
 	) {
 		const { chunkGraph, runtime } = context;
-		hash.update(`${chunkGraph.getModuleId(this)}`);
-		const exportsInfo = chunkGraph.moduleGraph.getExportsInfo(this);
-		exportsInfo.updateHash(hash, runtime);
+		hash.update(chunkGraph.getModuleGraphHash(this, runtime));
 		if (this.presentationalDependencies !== undefined) {
 			for (const dep of this.presentationalDependencies) {
 				dep.updateHash(hash, context);

package/lib/NormalModuleFactory.js

@@ -28,7 +28,7 @@ const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");
 const { join } = require("./util/fs");
 const { parseResource } = require("./util/identifier");
 
-/** @typedef {import("../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
+/** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("./Generator")} Generator */
 /** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
 /** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
@@ -147,10 +147,19 @@ const mergeGlobalOptions = (globalOptions, type, localOptions) => {
 };
 
 // TODO webpack 6 remove
-const deprecationChangedHookMessage = name =>
-	`NormalModuleFactory.${name} is no longer a waterfall hook, but a bailing hook instead. ` +
-	"Do not return the passed object, but modify it instead. " +
-	"Returning false will ignore the request and results in no module created.";
+const deprecationChangedHookMessage = (name, hook) => {
+	const names = hook.taps
+		.map(tapped => {
+			return tapped.name;
+		})
+		.join(", ");
+
+	return (
+		`NormalModuleFactory.${name} (${names}) is no longer a waterfall hook, but a bailing hook instead. ` +
+		"Do not return the passed object, but modify it instead. " +
+		"Returning false will ignore the request and results in no module created."
+	);
+};
 
 const dependencyCache = new WeakMap();
 
@@ -270,7 +279,7 @@ class NormalModuleFactory extends ModuleFactory {
 
 					if (typeof result === "object")
 						throw new Error(
-							deprecationChangedHookMessage("resolve") +
+							deprecationChangedHookMessage("resolve", this.hooks.resolve) +
 								" Returning a Module object will result in this module used as result."
 						);
 
@@ -278,7 +287,12 @@ class NormalModuleFactory extends ModuleFactory {
 						if (err) return callback(err);
 
 						if (typeof result === "object")
-							throw new Error(deprecationChangedHookMessage("afterResolve"));
+							throw new Error(
+								deprecationChangedHookMessage(
+									"afterResolve",
+									this.hooks.afterResolve
+								)
+							);
 
 						// Ignored
 						if (result === false) return callback();
@@ -682,7 +696,12 @@ class NormalModuleFactory extends ModuleFactory {
 			}
 
 			if (typeof result === "object")
-				throw new Error(deprecationChangedHookMessage("beforeResolve"));
+				throw new Error(
+					deprecationChangedHookMessage(
+						"beforeResolve",
+						this.hooks.beforeResolve
+					)
+				);
 
 			this.hooks.factorize.callAsync(resolveData, (err, module) => {
 				if (err) {

package/lib/Template.js

@@ -349,34 +349,43 @@ class Template {
 
 	/**
 	 * @param {RuntimeModule[]} runtimeModules array of runtime modules in order
-	 * @param {RenderContext} renderContext render context
+	 * @param {RenderContext & { codeGenerationResults?: CodeGenerationResults }} renderContext render context
 	 * @returns {Source} rendered runtime modules in a Source object
 	 */
 	static renderRuntimeModules(runtimeModules, renderContext) {
 		const source = new ConcatSource();
 		for (const module of runtimeModules) {
-			const codeGenResult = module.codeGeneration({
-				chunkGraph: renderContext.chunkGraph,
-				dependencyTemplates: renderContext.dependencyTemplates,
-				moduleGraph: renderContext.moduleGraph,
-				runtimeTemplate: renderContext.runtimeTemplate,
-				runtime: renderContext.chunk.runtime
-			});
-			if (codeGenResult) {
-				const moduleSource = codeGenResult.sources.get("runtime");
-				if (moduleSource) {
-					source.add(Template.toNormalComment(module.identifier()) + "\n");
-					if (!module.shouldIsolate()) {
-						source.add(moduleSource);
-					} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
-						source.add("(() => {\n");
-						source.add(new PrefixSource("\t", moduleSource));
-						source.add("\n})();\n\n");
-					} else {
-						source.add("!function() {\n");
-						source.add(new PrefixSource("\t", moduleSource));
-						source.add("\n}();\n\n");
-					}
+			const codeGenerationResults = renderContext.codeGenerationResults;
+			let runtimeSource;
+			if (codeGenerationResults) {
+				runtimeSource = codeGenerationResults.getSource(
+					module,
+					renderContext.chunk.runtime,
+					"runtime"
+				);
+			} else {
+				const codeGenResult = module.codeGeneration({
+					chunkGraph: renderContext.chunkGraph,
+					dependencyTemplates: renderContext.dependencyTemplates,
+					moduleGraph: renderContext.moduleGraph,
+					runtimeTemplate: renderContext.runtimeTemplate,
+					runtime: renderContext.chunk.runtime
+				});
+				if (!codeGenResult) continue;
+				runtimeSource = codeGenResult.sources.get("runtime");
+			}
+			if (runtimeSource) {
+				source.add(Template.toNormalComment(module.identifier()) + "\n");
+				if (!module.shouldIsolate()) {
+					source.add(runtimeSource);
+				} else if (renderContext.runtimeTemplate.supportsArrowFunction()) {
+					source.add("(() => {\n");
+					source.add(new PrefixSource("\t", runtimeSource));
+					source.add("\n})();\n\n");
+				} else {
+					source.add("!function() {\n");
+					source.add(new PrefixSource("\t", runtimeSource));
+					source.add("\n}();\n\n");
 				}
 			}
 		}

package/lib/WebpackIsIncludedPlugin.js

@@ -0,0 +1,85 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const IgnoreErrorModuleFactory = require("./IgnoreErrorModuleFactory");
+const WebpackIsIncludedDependency = require("./dependencies/WebpackIsIncludedDependency");
+const {
+	toConstantDependency
+} = require("./javascript/JavascriptParserHelpers");
+
+/** @typedef {import("enhanced-resolve/lib/Resolver")} Resolver */
+/** @typedef {import("./Compiler")} Compiler */
+/** @typedef {import("./Module")} Module */
+/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
+
+class WebpackIsIncludedPlugin {
+	/**
+	 * @param {Compiler} compiler the compiler instance
+	 * @returns {void}
+	 */
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"WebpackIsIncludedPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WebpackIsIncludedDependency,
+					new IgnoreErrorModuleFactory(normalModuleFactory)
+				);
+				compilation.dependencyTemplates.set(
+					WebpackIsIncludedDependency,
+					new WebpackIsIncludedDependency.Template()
+				);
+
+				/**
+				 * @param {JavascriptParser} parser the parser
+				 * @returns {void}
+				 */
+				const handler = parser => {
+					parser.hooks.call
+						.for("__webpack_is_included__")
+						.tap("WebpackIsIncludedPlugin", expr => {
+							if (
+								expr.type !== "CallExpression" ||
+								expr.arguments.length !== 1 ||
+								expr.arguments[0].type === "SpreadElement"
+							)
+								return;
+
+							const request = parser.evaluateExpression(expr.arguments[0]);
+
+							if (!request.isString()) return;
+
+							const dep = new WebpackIsIncludedDependency(
+								request.string,
+								expr.range
+							);
+							dep.loc = expr.loc;
+							parser.state.module.addDependency(dep);
+							return true;
+						});
+					parser.hooks.typeof
+						.for("__webpack_is_included__")
+						.tap(
+							"WebpackIsIncludedPlugin",
+							toConstantDependency(parser, JSON.stringify("function"))
+						);
+				};
+				normalModuleFactory.hooks.parser
+					.for("javascript/auto")
+					.tap("WebpackIsIncludedPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/dynamic")
+					.tap("WebpackIsIncludedPlugin", handler);
+				normalModuleFactory.hooks.parser
+					.for("javascript/esm")
+					.tap("WebpackIsIncludedPlugin", handler);
+			}
+		);
+	}
+}
+
+module.exports = WebpackIsIncludedPlugin;

package/lib/WebpackOptionsApply.js

@@ -22,6 +22,7 @@ const APIPlugin = require("./APIPlugin");
 const CompatibilityPlugin = require("./CompatibilityPlugin");
 const ConstPlugin = require("./ConstPlugin");
 const ExportsInfoApiPlugin = require("./ExportsInfoApiPlugin");
+const WebpackIsIncludedPlugin = require("./WebpackIsIncludedPlugin");
 
 const TemplatedPathPlugin = require("./TemplatedPathPlugin");
 const UseStrictPlugin = require("./UseStrictPlugin");
@@ -243,6 +244,27 @@ class WebpackOptionsApply extends OptionsApply {
 			}).apply(compiler);
 		}
 
+		if (options.experiments.lazyCompilation) {
+			const LazyCompilationPlugin = require("./hmr/LazyCompilationPlugin");
+			new LazyCompilationPlugin({
+				backend:
+					(typeof options.experiments.lazyCompilation === "object" &&
+						options.experiments.lazyCompilation.backend) ||
+					require("./hmr/lazyCompilationBackend"),
+				client:
+					(typeof options.experiments.lazyCompilation === "object" &&
+						options.experiments.lazyCompilation.client) ||
+					require.resolve(
+						`../hot/lazy-compilation-${
+							options.externalsPresets.node ? "node" : "web"
+						}.js`
+					),
+				entries:
+					typeof options.experiments.lazyCompilation !== "object" ||
+					options.experiments.lazyCompilation.entries !== false
+			}).apply(compiler);
+		}
+
 		new EntryOptionPlugin().apply(compiler);
 		compiler.hooks.entryOption.call(options.context, options.entry);
 
@@ -255,16 +277,15 @@ class WebpackOptionsApply extends OptionsApply {
 
 		new CompatibilityPlugin().apply(compiler);
 		new HarmonyModulesPlugin({
-			module: options.module,
 			topLevelAwait: options.experiments.topLevelAwait
 		}).apply(compiler);
 		if (options.amd !== false) {
 			const AMDPlugin = require("./dependencies/AMDPlugin");
 			const RequireJsStuffPlugin = require("./RequireJsStuffPlugin");
-			new AMDPlugin(options.module, options.amd || {}).apply(compiler);
+			new AMDPlugin(options.amd || {}).apply(compiler);
 			new RequireJsStuffPlugin().apply(compiler);
 		}
-		new CommonJsPlugin(options.module).apply(compiler);
+		new CommonJsPlugin().apply(compiler);
 		new LoaderPlugin().apply(compiler);
 		if (options.node !== false) {
 			const NodeStuffPlugin = require("./NodeStuffPlugin");
@@ -272,13 +293,14 @@ class WebpackOptionsApply extends OptionsApply {
 		}
 		new APIPlugin().apply(compiler);
 		new ExportsInfoApiPlugin().apply(compiler);
+		new WebpackIsIncludedPlugin().apply(compiler);
 		new ConstPlugin().apply(compiler);
 		new UseStrictPlugin().apply(compiler);
 		new RequireIncludePlugin().apply(compiler);
 		new RequireEnsurePlugin().apply(compiler);
 		new RequireContextPlugin().apply(compiler);
-		new ImportPlugin(options.module).apply(compiler);
-		new SystemPlugin(options.module).apply(compiler);
+		new ImportPlugin().apply(compiler);
+		new SystemPlugin().apply(compiler);
 		new ImportMetaPlugin().apply(compiler);
 		new URLPlugin().apply(compiler);
 

package/lib/cache/PackFileCacheStrategy.js

@@ -11,7 +11,10 @@ const { formatSize } = require("../SizeFormatHelpers");
 const LazySet = require("../util/LazySet");
 const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
-const { createFileSerializer } = require("../util/serialization");
+const {
+	createFileSerializer,
+	NOT_SERIALIZABLE
+} = require("../util/serialization");
 
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
 /** @typedef {import("../Cache").Etag} Etag */
@@ -525,6 +528,7 @@ class PackContentItems {
 					write(value);
 				} catch (e) {
 					rollback(s);
+					if (e === NOT_SERIALIZABLE) continue;
 					logger.warn(
 						`Skipped not serializable cache item '${key}': ${e.message}`
 					);

package/lib/config/defaults.js

@@ -27,7 +27,7 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").Loader} Loader */
 /** @typedef {import("../../declarations/WebpackOptions").Mode} Mode */
-/** @typedef {import("../../declarations/WebpackOptions").ModuleOptions} ModuleOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
 /** @typedef {import("../../declarations/WebpackOptions").Node} WebpackNode */
 /** @typedef {import("../../declarations/WebpackOptions").Optimization} Optimization */
 /** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} Output */
@@ -347,10 +347,25 @@ const applySnapshotDefaults = (snapshot, { production }) => {
 };
 
 /**
- * @param {JavascriptParserOptions} options options
+ * @param {JavascriptParserOptions} parserOptions parser options
  * @returns {void}
  */
-const applyJavascriptParserOptionsDefaults = options => {};
+const applyJavascriptParserOptionsDefaults = parserOptions => {
+	D(parserOptions, "unknownContextRequest", ".");
+	D(parserOptions, "unknownContextRegExp", false);
+	D(parserOptions, "unknownContextRecursive", true);
+	D(parserOptions, "unknownContextCritical", true);
+	D(parserOptions, "exprContextRequest", ".");
+	D(parserOptions, "exprContextRegExp", false);
+	D(parserOptions, "exprContextRecursive", true);
+	D(parserOptions, "exprContextCritical", true);
+	D(parserOptions, "wrappedContextRegExp", /.*/);
+	D(parserOptions, "wrappedContextRecursive", true);
+	D(parserOptions, "wrappedContextCritical", false);
+
+	D(parserOptions, "strictExportPresence", false);
+	D(parserOptions, "strictThisContextOnImports", false);
+};
 
 /**
  * @param {ModuleOptions} module options
@@ -364,21 +379,6 @@ const applyModuleDefaults = (
 	module,
 	{ cache, syncWebAssembly, asyncWebAssembly }
 ) => {
-	D(module, "unknownContextRequest", ".");
-	D(module, "unknownContextRegExp", false);
-	D(module, "unknownContextRecursive", true);
-	D(module, "unknownContextCritical", true);
-	D(module, "exprContextRequest", ".");
-	D(module, "exprContextRegExp", false);
-	D(module, "exprContextRecursive", true);
-	D(module, "exprContextCritical", true);
-	D(module, "wrappedContextRegExp", /.*/);
-	D(module, "wrappedContextRecursive", true);
-	D(module, "wrappedContextCritical", false);
-
-	D(module, "strictExportPresence", false);
-	D(module, "strictThisContextOnImports", false);
-
 	if (cache) {
 		D(module, "unsafeCache", module => {
 			const name = module.nameForCondition();

package/lib/config/normalization.js

@@ -83,15 +83,31 @@ const optionalNestedArray = (value, fn) =>
  * @template R
  * @param {Record<string, T>|undefined} value value or not
  * @param {function(T): R} fn nested handler
+ * @param {Record<string, function(T): R>=} customKeys custom nested handler for some keys
  * @returns {Record<string, R>} result value
  */
-const keyedNestedConfig = (value, fn) =>
-	value === undefined
-		? {}
-		: Object.keys(value).reduce(
-				(obj, key) => ((obj[key] = fn(value[key])), obj),
-				/** @type {Record<string, R>} */ ({})
-		  );
+const keyedNestedConfig = (value, fn, customKeys) => {
+	const result =
+		value === undefined
+			? {}
+			: Object.keys(value).reduce(
+					(obj, key) => (
+						(obj[key] = (customKeys && key in customKeys
+							? customKeys[key]
+							: fn)(value[key])),
+						obj
+					),
+					/** @type {Record<string, R>} */ ({})
+			  );
+	if (customKeys) {
+		for (const key of Object.keys(customKeys)) {
+			if (!(key in result)) {
+				result[key] = customKeys[key](/** @type {T} */ ({}));
+			}
+		}
+	}
+	return result;
+};
 
 /**
  * @param {WebpackOptions} config input config
@@ -180,9 +196,28 @@ const getNormalizedWebpackOptions = config => {
 		loader: cloneObject(config.loader),
 		mode: config.mode,
 		module: nestedConfig(config.module, module => ({
-			...module,
-			parser: cloneObject(module.parser),
+			noParse: module.noParse,
+			unsafeCache: module.unsafeCache,
+			parser: keyedNestedConfig(module.parser, cloneObject, {
+				javascript: parserOptions => ({
+					unknownContextRequest: module.unknownContextRequest,
+					unknownContextRegExp: module.unknownContextRegExp,
+					unknownContextRecursive: module.unknownContextRecursive,
+					unknownContextCritical: module.unknownContextCritical,
+					exprContextRequest: module.exprContextRequest,
+					exprContextRegExp: module.exprContextRegExp,
+					exprContextRecursive: module.exprContextRecursive,
+					exprContextCritical: module.exprContextCritical,
+					wrappedContextRegExp: module.wrappedContextRegExp,
+					wrappedContextRecursive: module.wrappedContextRecursive,
+					wrappedContextCritical: module.wrappedContextCritical,
+					strictExportPresence: module.strictExportPresence,
+					strictThisContextOnImports: module.strictThisContextOnImports,
+					...parserOptions
+				})
+			}),
 			generator: cloneObject(module.generator),
+			defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
 			rules: nestedArray(module.rules, r => [...r])
 		})),
 		name: config.name,