@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/NormalModule.js

@@ -8,9 +8,9 @@
 const querystring = require("querystring");
 const {
 	AsyncSeriesBailHook,
+	AsyncSeriesWaterfallHook,
 	HookMap,
-	SyncHook,
-	SyncWaterfallHook
+	SyncHook
 } = require("tapable");
 const {
 	CachedSource,
@@ -19,6 +19,7 @@ const {
 	SourceMapSource
 } = require("webpack-sources");
 const Dependency = require("./Dependency");
+const { toError } = require("./ErrorHelpers");
 const Module = require("./Module");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");
@@ -33,6 +34,7 @@ const {
 const LazySet = require("./util/LazySet");
 const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
+const { getBuildDiagnostics } = require("./util/buildDiagnostics");
 const {
 	concatComparators,
 	keepOriginalOrder,
@@ -67,10 +69,6 @@ const getUnhandledSchemeError = memoize(() =>
 	require("./errors/UnhandledSchemeError")
 );
 
-const getNonErrorEmittedError = memoize(() =>
-	require("./errors/NonErrorEmittedError")
-);
-
 const getModuleWarning = memoize(() => require("./errors/ModuleWarning"));
 
 const getModuleParseError = memoize(() => require("./errors/ModuleParseError"));
@@ -79,17 +77,21 @@ const getModuleError = memoize(() => require("./errors/ModuleError"));
 
 const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
 
-/** @import { ResolveContext, ResolveRequest } from "enhanced-resolve" */
+/** @import { ResolveContext, ResolveRequest, Resolver } from "enhanced-resolve" */
 /** @import { Source, RawSourceMap } from "webpack-sources" */
 /**
  * @import {
  * 	ResolveOptions,
  * 	NoParse,
- * 	HashFunction
+ * 	HashFunction,
+ * 	HashDigest,
+ * 	HashDigestLength,
+ * 	HashSalt
  * } from "../declarations/WebpackOptions"
  */
 /**
  * @import Compilation, {
+ * 	AssetInfo,
  * 	FileSystemDependencies,
  * 	UnsafeCacheData
  * } from "./Compilation"
@@ -136,7 +138,14 @@ const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
  */
 /** @import Parser, { PreparsedAst } from "./Parser" */
 /** @import RequestShortener from "./RequestShortener" */
-/** @import { ResolverWithOptions } from "./ResolverFactory" */
+/** @import Compiler from "./Compiler" */
+/** @import { Logger } from "./logging/Logger" */
+/**
+ * @import {
+ * 	ResolverWithOptions,
+ * 	ResolveOptionsWithDependencyType
+ * } from "./ResolverFactory"
+ */
 /**
  * @import {
  * 	ObjectDeserializerContext,
@@ -154,14 +163,65 @@ const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
 /** @typedef {{ [k: string]: EXPECTED_ANY }} ParserOptions */
 /** @typedef {{ [k: string]: EXPECTED_ANY }} GeneratorOptions */
 
+/** @typedef {Parameters<Resolver["resolve"]>[4]} ResolveCallback */
+/** @typedef {Parameters<typeof import("schema-utils").validate>[0]} Schema */
+
 /**
- * @template T
- * @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ * `getOptions` validates against a schema when given one, and TypeScript reads
+ * an intersection of call signatures as an overload set
+ * @template OptionsType
+ * @typedef {{ (): OptionsType } & { (schema: Schema): OptionsType }} GetOptionsMethod
+ */
+
+/**
+ * @typedef {((context: string, request: string, callback: ResolveCallback) => void) & ((context: string, request: string) => Promise<string>)} DualModeResolve
+ */
+
+/**
+ * @typedef {object} LoaderContextUtils
+ * @property {(context: string, request: string) => string} absolutify returns a new request string using absolute paths when possible
+ * @property {(context: string, request: string) => string} contextify returns a new request string avoiding absolute paths when possible
+ * @property {(algorithm?: string | typeof Hash) => Hash} createHash creates a hash with the compilation's function
+ */
+
+/**
+ * These properties are added by the NormalModule
+ * @template OptionsType
+ * @typedef {object} NormalModuleLoaderContext
+ * @property {number} version
+ * @property {GetOptionsMethod<OptionsType>} getOptions Extracts and parses the options of the current loader.
+ * Parses string options as JSON or a query string.
+ * @property {(warning: Error | string) => void} emitWarning Emits a warning for this module.
+ * The warning will be displayed to the user during compilation.
+ * @property {(error: Error | string) => void} emitError Emits an error for this module.
+ * The error will be displayed to the user and typically causes the compilation to fail.
+ * @property {(name?: string) => Logger} getLogger Gets a logger instance scoped to this loader and module.
+ * Useful for emitting debug or compilation information in a structured way.
+ * @property {(context: string, request: string, callback: ResolveCallback) => void} resolve Resolves a module request (e.g., a relative path or module name) to an absolute file path.
+ * It uses Webpack's internal resolver, taking into account configured aliases and extensions.
+ * @property {(options?: ResolveOptionsWithDependencyType) => DualModeResolve} getResolve Creates a resolve function with specific options.
+ * The returned function can be used as a Promise-based resolver or a callback-based resolver.
+ * @property {(name: string, content: string | Buffer, sourceMap?: string, assetInfo?: AssetInfo) => void} emitFile Emits a new file (asset) to the compilation output directory.
+ * This allows loaders to generate additional files alongside the main module output.
+ * @property {(dep: string) => void} addBuildDependency
+ * @property {LoaderContextUtils} utils
+ * @property {string} rootContext
+ * @property {InputFileSystem} fs
+ * @property {boolean=} sourceMap
+ * @property {"development" | "production" | "none"} mode
+ * @property {boolean=} webpack
+ * @property {HashFunction} hashFunction
+ * @property {HashDigest} hashDigest
+ * @property {HashDigestLength} hashDigestLength
+ * @property {HashSalt=} hashSalt
+ * @property {NormalModule=} _module
+ * @property {Compilation=} _compilation
+ * @property {Compiler=} _compiler
  */
 
 /**
  * @template T
- * @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} NormalModuleLoaderContext
+ * @typedef {NormalModuleLoaderContext<T> & import("./loaders/LoaderRunner").LoaderRunnerLoaderContext<T> & import("./dependencies/LoaderPlugin").LoaderPluginLoaderContext & import("./HotModuleReplacementPlugin").HotModuleReplacementPluginLoaderContext} LoaderContext
  */
 
 /** @typedef {(content: string) => boolean} NoParseFn */
@@ -182,7 +242,9 @@ const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
 		.getOptimizationBailout(mod)
 		.push(
 			() =>
-				`Dependency (${dep.type}) with side effects at ${formatLocation(dep.loc)}`
+				`Dependency (${dep.type}) with side effects at ${formatLocation(
+					dep.loc
+				)}`
 		);
 };
 
@@ -345,10 +407,9 @@ const walkSideEffects = (rootMod, moduleGraph, SideEffectDep) => {
 						}
 					}
 				} else {
-					// Non-NormalModule (e.g. ConcatenatedModule delegating back
-					// through here) resolves via a re-entrant walk that may see our
-					// in-progress modules as circular, so taint this chain: never
-					// memoize it.
+					// A non-NormalModule resolves through a re-entrant walk that may read
+					// our in-progress modules as circular, so this chain is tainted and
+					// never memoized.
 					state = refModule.getSideEffectsConnectionState(moduleGraph);
 					lowOf.set(mod, -1);
 				}
@@ -540,10 +601,12 @@ const createCompilationHooks = () => {
 		 */
 		beforeSnapshot: new SyncHook(["module"]),
 		/**
-		 * @type {SyncWaterfallHook<[Result, NormalModule]>}
+		 * Async since 5.111.0, so a tap can await work of its own — minifying an
+		 * asset, say, which before only a loader could do. `tap` keeps working.
+		 * @type {AsyncSeriesWaterfallHook<[Result, NormalModule]>}
 		 * @since 5.99.0
 		 */
-		processResult: new SyncWaterfallHook(["result", "module"]),
+		processResult: new AsyncSeriesWaterfallHook(["result", "module"]),
 		/**
 		 * @type {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>}
 		 * @since 5.49.0
@@ -947,7 +1010,7 @@ class NormalModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
 	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @returns {import("../declarations/LoaderContext").LoaderContext<T>} loader context
+	 * @returns {LoaderContext<T>} loader context
 	 */
 	_createLoaderContext(resolver, options, compilation, fs, hooks) {
 		const { requestShortener } = compilation.runtimeTemplate;
@@ -1045,7 +1108,9 @@ class NormalModule extends Module {
 								(parseJson(options));
 						} catch (err) {
 							throw new Error(
-								`Cannot parse string options: ${/** @type {Error} */ (err).message}`,
+								`Cannot parse string options: ${
+									/** @type {Error} */ (err).message
+								}`,
 								{ cause: err }
 							);
 						}
@@ -1078,22 +1143,16 @@ class NormalModule extends Module {
 			},
 			/** @type {LoaderContext<EXPECTED_ANY>["emitWarning"]} */
 			emitWarning: (warning) => {
-				if (!(warning instanceof Error)) {
-					warning = new (getNonErrorEmittedError())(warning);
-				}
 				this.addWarning(
-					new (getModuleWarning())(warning, {
+					new (getModuleWarning())(toError(warning), {
 						from: getCurrentLoaderName()
 					})
 				);
 			},
 			/** @type {LoaderContext<EXPECTED_ANY>["emitError"]} */
 			emitError: (error) => {
-				if (!(error instanceof Error)) {
-					error = new (getNonErrorEmittedError())(error);
-				}
 				this.addError(
-					new (getModuleError())(error, {
+					new (getModuleError())(toError(error), {
 						from: getCurrentLoaderName()
 					})
 				);
@@ -1117,7 +1176,7 @@ class NormalModule extends Module {
 			/** @type {LoaderContext<EXPECTED_ANY>["getResolve"]} */
 			getResolve(options) {
 				const child = options ? resolver.withOptions(options) : resolver;
-				return /** @type {ReturnType<import("../declarations/LoaderContext").NormalModuleLoaderContext<T>["getResolve"]>} */ (
+				return /** @type {ReturnType<NormalModuleLoaderContext<T>["getResolve"]>} */ (
 					(context, request, callback) => {
 						if (callback) {
 							child.resolve(
@@ -1285,11 +1344,8 @@ class NormalModule extends Module {
 		 */
 		const processResult = (err, result_) => {
 			if (err) {
-				if (!(err instanceof Error)) {
-					err = new (getNonErrorEmittedError())(err);
-				}
 				const currentLoader = this.getCurrentLoader(loaderContext);
-				const error = new (getModuleBuildError())(err, {
+				const error = new (getModuleBuildError())(toError(err), {
 					from:
 						currentLoader &&
 						compilation.runtimeTemplate.requestShortener.shorten(
@@ -1298,11 +1354,30 @@ class NormalModule extends Module {
 				});
 				return callback(error);
 			}
-			const result = hooks.processResult.call(
+			hooks.processResult.callAsync(
 				/** @type {Result} */
 				(result_),
-				this
+				this,
+				(hookErr, hookResult) => {
+					if (hookErr) {
+						// Named, so a tap's failure is not read as a loader's.
+						return callback(
+							new (getModuleBuildError())(toError(hookErr), {
+								from: "processResult hook"
+							})
+						);
+					}
+
+					finishResult(/** @type {Result} */ (hookResult));
+				}
 			);
+		};
+
+		/**
+		 * @param {Result} result the result the hook settled on
+		 * @returns {void}
+		 */
+		const finishResult = (result) => {
 			const source = result[0];
 			const sourceMap = result.length >= 1 ? result[1] : null;
 			const extraInfo = result.length >= 2 ? result[2] : null;
@@ -1434,7 +1509,9 @@ class NormalModule extends Module {
 												})
 										).catch((err) => {
 											throw new Error(
-												`Failed to parse source map. ${/** @type {Error} */ (err).message}`
+												`Failed to parse source map. ${
+													/** @type {Error} */ (err).message
+												}`
 											);
 										})
 								);
@@ -1494,7 +1571,8 @@ class NormalModule extends Module {
 				}
 				buildInfo.cacheable = buildInfo.cacheable && result.cacheable;
 				if (result.notCacheableReasons.length > 0) {
-					buildInfo.notCacheableReasons = result.notCacheableReasons;
+					getBuildDiagnostics(buildInfo).notCacheableReasons =
+						result.notCacheableReasons;
 				}
 				processResult(err, result.result);
 			}
@@ -1502,14 +1580,16 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {Error} error the error
+	 * Marks the module as failed, so what it generates says so. A tap or a
+	 * loader may fail with anything, and what reads the failure expects an error.
+	 * @param {EXPECTED_ANY} error what the module failed with
 	 * @returns {void}
 	 */
 	markModuleAsErrored(error) {
 		// Restore build meta from successful build to keep importing state
 		this.buildMeta = { ...this._lastSuccessfulBuildMeta };
-		this.error = error;
-		this.addError(error);
+		this.error = toError(error);
+		this.addError(this.error);
 	}
 
 	/**
@@ -1602,7 +1682,6 @@ class NormalModule extends Module {
 		};
 		this.buildInfo = {
 			cacheable: false,
-			notCacheableReasons: undefined,
 			parsed: true,
 			fileDependencies: undefined,
 			contextDependencies: undefined,
@@ -1620,6 +1699,8 @@ class NormalModule extends Module {
 			pureFunctions: undefined,
 			inlineExports: undefined,
 			moduleConcatenationBailout: undefined,
+			moduleConcatenationRootBailout: undefined,
+			diagnostics: undefined,
 			needCreateRequire: undefined,
 			usesTopLevelUsingDeclaration: undefined
 		};
@@ -1675,7 +1756,7 @@ class NormalModule extends Module {
 				try {
 					hooks.beforeSnapshot.call(this);
 				} catch (err) {
-					this.markModuleAsErrored(/** @type {Error} */ (err));
+					this.markModuleAsErrored(err);
 					return callback();
 				}
 
@@ -1769,7 +1850,7 @@ class NormalModule extends Module {
 			try {
 				hooks.beforeParse.call(this);
 			} catch (err) {
-				this.markModuleAsErrored(/** @type {Error} */ (err));
+				this.markModuleAsErrored(err);
 				this._initBuildHash(compilation);
 				return callback();
 			}
@@ -1917,7 +1998,13 @@ class NormalModule extends Module {
 							getData,
 							type
 						})
-					: new RawSource(getGenerator().throwBuildErrorCode(this.error))
+					: new RawSource(
+							getGenerator().throwBuildErrorCode(
+								this.error,
+								undefined,
+								runtimeTemplate.requestShortener
+							)
+						)
 				: generator.generate(this, {
 						dependencyTemplates,
 						runtimeTemplate,
@@ -2083,10 +2170,8 @@ class NormalModule extends Module {
 			/** @type {string} */
 			(buildInfo.hash)
 		);
-		// Clear cached source types and re-compute so that changes in incoming
-		// connections (e.g. asset module newly referenced from JS via lazy
-		// compilation) are reflected in the hash and trigger code generation
-		// cache invalidation.
+		// Recompute the source types, so a change in the incoming connections reaches
+		// the hash and invalidates the code-generation cache.
 		// https://github.com/webpack/webpack/issues/20800
 		this._sourceTypes = undefined;
 		for (const type of this.getSourceTypes()) {
@@ -2137,7 +2222,7 @@ class NormalModule extends Module {
 			parserOptions: /** @type {EXPECTED_ANY} */ (null),
 			generator: /** @type {EXPECTED_ANY} */ (null),
 			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
-			resolveOptions: /** @type {EXPECTED_ANY} */ (null),
+			resolveOptions: undefined,
 			extractSourceMap: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);

package/lib/NormalModuleFactory.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const {
 	AsyncSeriesBailHook,
 	AsyncSeriesHook,
@@ -30,6 +29,7 @@ const RuleSetCompiler = require("./rules/RuleSetCompiler");
 const UseEffectRulePlugin = require("./rules/UseEffectRulePlugin");
 const LazySet = require("./util/LazySet");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
+const asyncLib = require("./util/async");
 const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");
 const {
 	applyCaseCorrections,

package/lib/RuntimeGlobals.js

@@ -15,13 +15,6 @@ module.exports.amdDefine = "__webpack_require__.amdD";
  */
 module.exports.amdOptions = "__webpack_require__.amdO";
 
-/**
- * analyzable single-chunk `import()` that keeps `ensureChunk` timing and deduplication:
- * resolves immediately for an installed chunk, else runs the literal import and installs it
- * Signature: (chunkId, () => Promise) => Promise
- */
-module.exports.analyzableChunkImport = "__webpack_require__.ei";
-
 /**
  * Creates an async module. The body function must be a async function.
  * "module.exports" will be decorated with an AsyncModulePromise.
@@ -254,12 +247,28 @@ module.exports.hasCssModules = "has css modules";
  */
 module.exports.hasFetchPriority = "has fetch priority";
 
+/**
+ * a flag when a deferred startup callback carries a priority
+ */
+module.exports.hasChunkPriority = "has chunk priority";
+
 /**
  * the shorthand for Object.prototype.hasOwnProperty
  * using of it decreases the compiled bundle size
  */
 module.exports.hasOwnProperty = "__webpack_require__.o";
 
+/**
+ * a flag when a deferred namespace is built from a known export list
+ */
+module.exports.hasSealedDeferredNamespace = "has sealed deferred namespace";
+
+/**
+ * a flag when a deferred namespace is synthesized from the module's exports
+ */
+module.exports.hasSynthesizedDeferredNamespace =
+	"has synthesized deferred namespace";
+
 /**
  * function downloading the update manifest
  */
@@ -447,6 +456,11 @@ module.exports.setAnonymousDefaultName = "__webpack_require__.dn";
  */
 module.exports.shareScopeMap = "__webpack_require__.S";
 
+/**
+ * wrap an exports object in a spec Module Namespace Exotic Object
+ */
+module.exports.specNamespaceObject = "__webpack_require__.ns";
+
 /**
  * startup signal from runtime
  * This will be called when the runtime chunk has been loaded.

package/lib/RuntimeModule.js

@@ -136,22 +136,31 @@ class RuntimeModule extends Module {
 	updateHash(hash, context) {
 		hash.update(this.name);
 		hash.update(`${this.stage}`);
-		try {
-			const code =
-				this.fullHash || this.dependentHash
-					? // Do not use getGeneratedCode here, because i. e. compilation hash might be not
-						// ready at this point. We will cache it later instead.
-						this.generate()
-					: this.getGeneratedCode();
-			if (code !== null && code !== undefined) {
-				hash.update(code);
-			}
-		} catch (err) {
-			hash.update(/** @type {Error} */ (err).message);
+		// A failing `generate()` propagates: hashing its message instead pins the etag
+		// of the code generation cache to a constant, which then serves stale code.
+		const code =
+			this.fullHash || this.dependentHash
+				? // Do not use getGeneratedCode here, because i. e. compilation hash might be not
+					// ready at this point. We will cache it later instead.
+					this.generate()
+				: this.getGeneratedCode();
+		if (code !== null && code !== undefined) {
+			hash.update(code);
 		}
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		// Answering `null` rather than "none" keeps a module that never heard of this
+		// out of a dispatch that would skip the handler it installs.
+		return null;
+	}
+
 	/**
 	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
@@ -244,6 +253,13 @@ class RuntimeModule extends Module {
 	}
 }
 
+/**
+ * The answer a runtime module gives when it installs no chunk handler at all
+ */
+RuntimeModule.NO_CHUNK_HANDLERS =
+	/** @type {[string, string][]} */
+	([]);
+
 /**
  * Runtime modules without any dependencies to other runtime modules
  */

package/lib/RuntimePlugin.js

@@ -81,6 +81,9 @@ const getGetWorkletBootstrapRuntimeModule = lazyModule(() =>
 const getGlobalRuntimeModule = lazyModule(() =>
 	require("./runtime/GlobalRuntimeModule")
 );
+const getSpecNamespaceObjectRuntimeModule = lazyModule(() =>
+	require("./runtime/SpecNamespaceObjectRuntimeModule")
+);
 const getHasOwnPropertyRuntimeModule = lazyModule(() =>
 	require("./runtime/HasOwnPropertyRuntimeModule")
 );
@@ -214,6 +217,7 @@ const SIMPLE_TREE_RUNTIME_MODULES = [
 		getCreateFakeNamespaceObjectRuntimeModule
 	],
 	[RuntimeGlobals.hasOwnProperty, getHasOwnPropertyRuntimeModule],
+	[RuntimeGlobals.specNamespaceObject, getSpecNamespaceObjectRuntimeModule],
 	[
 		RuntimeGlobals.compatGetDefaultExport,
 		getCompatGetDefaultExportRuntimeModule
@@ -229,7 +233,6 @@ const SIMPLE_TREE_RUNTIME_MODULES = [
 	[RuntimeGlobals.shareScopeMap, getShareRuntimeModule],
 	[RuntimeGlobals.relativeUrl, getRelativeUrlRuntimeModule],
 	[RuntimeGlobals.worker, getWorkerRuntimeModule],
-	[RuntimeGlobals.onChunksLoaded, getOnChunksLoadedRuntimeModule],
 	[RuntimeGlobals.scriptNonce, getNonceRuntimeModule],
 	[RuntimeGlobals.toBinary, getToBinaryRuntimeModule]
 ];
@@ -316,6 +319,16 @@ class RuntimePlugin {
 						return true;
 					});
 			}
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.onChunksLoaded)
+				.tap(PLUGIN_NAME, (chunk, runtimeRequirement) => {
+					compilation.addLazyRuntimeModule(
+						chunk,
+						getOnChunksLoadedRuntimeModule,
+						(Ctor) => new Ctor(runtimeRequirement)
+					);
+					return true;
+				});
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.definePropertyGetters)
 				.tap(PLUGIN_NAME, (chunk, runtimeRequirement) => {
@@ -345,10 +358,20 @@ class RuntimePlugin {
 					const asyncModule = runtimeRequirement.has(
 						RuntimeGlobals.asyncModule
 					);
+					const sealed = runtimeRequirement.has(
+						RuntimeGlobals.hasSealedDeferredNamespace
+					);
+					// An unmarked build keeps both shapes, so a call site that
+					// predates the markers still gets the permissive runtime.
+					const synthesized =
+						!sealed ||
+						runtimeRequirement.has(
+							RuntimeGlobals.hasSynthesizedDeferredNamespace
+						);
 					compilation.addLazyRuntimeModule(
 						chunk,
 						getMakeDeferredNamespaceObjectRuntimeModule,
-						(Ctor) => new Ctor(asyncModule)
+						(Ctor) => new Ctor(asyncModule, sealed, synthesized)
 					);
 					return true;
 				});
@@ -402,7 +425,11 @@ class RuntimePlugin {
 					compilation.addLazyRuntimeModule(
 						chunk,
 						getAsyncModuleRuntimeModule,
-						(Ctor) => new Ctor(experiments.deferImport)
+						(Ctor) =>
+							new Ctor(
+								experiments.deferImport,
+								compilation.outputOptions.strictModuleErrorHandling
+							)
 					);
 					return true;
 				});