webpack 5.100.1 → 5.101.0

package/lib/MultiCompiler.js

@@ -16,6 +16,7 @@ const ArrayQueue = require("./util/ArrayQueue");
 
 /** @template T @typedef {import("tapable").AsyncSeriesHook<T>} AsyncSeriesHook<T> */
 /** @template T @template R @typedef {import("tapable").SyncBailHook<T, R>} SyncBailHook<T, R> */
+/** @typedef {import("../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
 /** @typedef {import("../declarations/WebpackOptions").WatchOptions} WatchOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Stats")} Stats */
@@ -44,6 +45,8 @@ const ArrayQueue = require("./util/ArrayQueue");
  * @property {number=} parallelism how many Compilers are allows to run at the same time in parallel
  */
 
+/** @typedef {ReadonlyArray<WebpackOptions> & MultiCompilerOptions} MultiWebpackOptions */
+
 const CLASS_NAME = "MultiCompiler";
 
 module.exports = class MultiCompiler {
@@ -54,7 +57,7 @@ module.exports = class MultiCompiler {
 	constructor(compilers, options) {
 		if (!Array.isArray(compilers)) {
 			/** @type {Compiler[]} */
-			compilers = Object.keys(compilers).map(name => {
+			compilers = Object.keys(compilers).map((name) => {
 				/** @type {Record<string, Compiler>} */
 				(compilers)[name].name = name;
 				return /** @type {Record<string, Compiler>} */ (compilers)[name];
@@ -65,16 +68,16 @@ module.exports = class MultiCompiler {
 			/** @type {SyncHook<[MultiStats]>} */
 			done: new SyncHook(["stats"]),
 			/** @type {MultiHook<SyncHook<[string | null, number]>>} */
-			invalid: new MultiHook(compilers.map(c => c.hooks.invalid)),
+			invalid: new MultiHook(compilers.map((c) => c.hooks.invalid)),
 			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-			run: new MultiHook(compilers.map(c => c.hooks.run)),
+			run: new MultiHook(compilers.map((c) => c.hooks.run)),
 			/** @type {SyncHook<[]>} */
 			watchClose: new SyncHook([]),
 			/** @type {MultiHook<AsyncSeriesHook<[Compiler]>>} */
-			watchRun: new MultiHook(compilers.map(c => c.hooks.watchRun)),
+			watchRun: new MultiHook(compilers.map((c) => c.hooks.watchRun)),
 			/** @type {MultiHook<SyncBailHook<[string, string, EXPECTED_ANY[] | undefined], true | void>>} */
 			infrastructureLog: new MultiHook(
-				compilers.map(c => c.hooks.infrastructureLog)
+				compilers.map((c) => c.hooks.infrastructureLog)
 			)
 		});
 		this.compilers = compilers;
@@ -94,7 +97,7 @@ module.exports = class MultiCompiler {
 			const compilerIndex = index;
 			let compilerDone = false;
 			// eslint-disable-next-line no-loop-func
-			compiler.hooks.done.tap(CLASS_NAME, stats => {
+			compiler.hooks.done.tap(CLASS_NAME, (stats) => {
 				if (!compilerDone) {
 					compilerDone = true;
 					doneCompilers++;
@@ -124,7 +127,7 @@ module.exports = class MultiCompiler {
 		 * @param {WebpackError} warning warning
 		 */
 		const addWarning = (compiler, warning) => {
-			compiler.hooks.thisCompilation.tap(CLASS_NAME, compilation => {
+			compiler.hooks.thisCompilation.tap(CLASS_NAME, (compilation) => {
 				compilation.warnings.push(warning);
 			});
 		};
@@ -152,7 +155,7 @@ module.exports = class MultiCompiler {
 
 	get options() {
 		return Object.assign(
-			this.compilers.map(c => c.options),
+			this.compilers.map((c) => c.options),
 			this._options
 		);
 	}
@@ -254,7 +257,7 @@ module.exports = class MultiCompiler {
 		 * @param {Compiler} compiler compiler
 		 * @returns {boolean} target was found
 		 */
-		const targetFound = compiler => {
+		const targetFound = (compiler) => {
 			for (const edge of edges) {
 				if (edge.target === compiler) {
 					return true;
@@ -276,7 +279,7 @@ module.exports = class MultiCompiler {
 			const dependencies = this.dependencies.get(source);
 			if (dependencies) {
 				for (const dep of dependencies) {
-					const target = this.compilers.find(c => c.name === dep);
+					const target = this.compilers.find((c) => c.name === dep);
 					if (!target) {
 						missing.push(dep);
 					} else {
@@ -289,8 +292,10 @@ module.exports = class MultiCompiler {
 			}
 		}
 		/** @type {string[]} */
-		const errors = missing.map(m => `Compiler dependency \`${m}\` not found.`);
-		const stack = this.compilers.filter(c => !targetFound(c));
+		const errors = missing.map(
+			(m) => `Compiler dependency \`${m}\` not found.`
+		);
+		const stack = this.compilers.filter((c) => !targetFound(c));
 		while (stack.length > 0) {
 			const current = stack.pop();
 			for (const edge of edges) {
@@ -307,7 +312,7 @@ module.exports = class MultiCompiler {
 			/** @type {string[]} */
 			const lines = [...edges]
 				.sort(sortEdges)
-				.map(edge => `${edge.source.name} -> ${edge.target.name}`);
+				.map((edge) => `${edge.source.name} -> ${edge.target.name}`);
 			lines.unshift("Circular dependency found in compiler dependencies.");
 			errors.unshift(lines.join("\n"));
 		}
@@ -334,7 +339,7 @@ module.exports = class MultiCompiler {
 		 * @param {string} d dependency
 		 * @returns {boolean} when dependency was fulfilled
 		 */
-		const isDependencyFulfilled = d => fulfilledNames.has(d);
+		const isDependencyFulfilled = (d) => fulfilledNames.has(d);
 		/**
 		 * @returns {Compiler[]} compilers
 		 */
@@ -358,12 +363,12 @@ module.exports = class MultiCompiler {
 		 * @param {Callback<Stats[]>} callback callback
 		 * @returns {void}
 		 */
-		const runCompilers = callback => {
+		const runCompilers = (callback) => {
 			if (remainingCompilers.length === 0) return callback(null);
 			asyncLib.map(
 				getReadyCompilers(),
 				(compiler, callback) => {
-					fn(compiler, err => {
+					fn(compiler, (err) => {
 						if (err) return callback(err);
 						fulfilledNames.add(compiler.name);
 						runCompilers(callback);
@@ -400,7 +405,7 @@ module.exports = class MultiCompiler {
 		// running-outdated -> blocked [running--] (when compilation is done)
 
 		/** @type {Node[]} */
-		const nodes = this.compilers.map(compiler => ({
+		const nodes = this.compilers.map((compiler) => ({
 			compiler,
 			setupResult: undefined,
 			result: undefined,
@@ -472,7 +477,7 @@ module.exports = class MultiCompiler {
 		 * @param {Node} node node
 		 * @returns {void}
 		 */
-		const nodeInvalidFromParent = node => {
+		const nodeInvalidFromParent = (node) => {
 			if (node.state === "done") {
 				node.state = "blocked";
 			} else if (node.state === "running") {
@@ -486,7 +491,7 @@ module.exports = class MultiCompiler {
 		 * @param {Node} node node
 		 * @returns {void}
 		 */
-		const nodeInvalid = node => {
+		const nodeInvalid = (node) => {
 			if (node.state === "done") {
 				node.state = "pending";
 			} else if (node.state === "running") {
@@ -500,7 +505,7 @@ module.exports = class MultiCompiler {
 		 * @param {Node} node node
 		 * @returns {void}
 		 */
-		const nodeChange = node => {
+		const nodeChange = (node) => {
 			nodeInvalid(node);
 			if (node.state === "pending") {
 				node.state = "blocked";
@@ -538,7 +543,7 @@ module.exports = class MultiCompiler {
 				if (
 					node.state === "queued" ||
 					(node.state === "blocked" &&
-						node.parents.every(p => p.state === "done"))
+						node.parents.every((p) => p.state === "done"))
 				) {
 					running++;
 					node.state = "starting";
@@ -554,7 +559,7 @@ module.exports = class MultiCompiler {
 			if (
 				!errored &&
 				running === 0 &&
-				nodes.every(node => node.state === "done")
+				nodes.every((node) => node.state === "done")
 			) {
 				const stats = [];
 				for (const node of nodes) {
@@ -574,7 +579,7 @@ module.exports = class MultiCompiler {
 	}
 
 	/**
-	 * @param {WatchOptions|WatchOptions[]} watchOptions the watcher's options
+	 * @param {WatchOptions | WatchOptions[]} watchOptions the watcher's options
 	 * @param {Callback<MultiStats>} handler signals when the call finishes
 	 * @returns {MultiWatching} a compiler watcher
 	 */
@@ -653,7 +658,7 @@ module.exports = class MultiCompiler {
 			(compiler, callback) => {
 				compiler.close(callback);
 			},
-			error => {
+			(error) => {
 				callback(error);
 			}
 		);

package/lib/MultiStats.js

@@ -25,6 +25,8 @@ const indent = (str, prefix) => {
 	return prefix + rem;
 };
 
+/** @typedef {undefined | string | boolean | StatsOptions} ChildrenStatsOptions */
+/** @typedef {Omit<StatsOptions, "children"> & { children?: ChildrenStatsOptions | ChildrenStatsOptions[] }} MultiStatsOptions */
 /** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */
 
 class MultiStats {
@@ -36,25 +38,25 @@ class MultiStats {
 	}
 
 	get hash() {
-		return this.stats.map(stat => stat.hash).join("");
+		return this.stats.map((stat) => stat.hash).join("");
 	}
 
 	/**
 	 * @returns {boolean} true if a child compilation encountered an error
 	 */
 	hasErrors() {
-		return this.stats.some(stat => stat.hasErrors());
+		return this.stats.some((stat) => stat.hasErrors());
 	}
 
 	/**
 	 * @returns {boolean} true if a child compilation had a warning
 	 */
 	hasWarnings() {
-		return this.stats.some(stat => stat.hasWarnings());
+		return this.stats.some((stat) => stat.hasWarnings());
 	}
 
 	/**
-	 * @param {string | boolean | StatsOptions | undefined} options stats options
+	 * @param {undefined | string | boolean | MultiStatsOptions} options stats options
 	 * @param {CreateStatsOptionsContext} context context
 	 * @returns {ChildOptions} context context
 	 */
@@ -80,6 +82,9 @@ class MultiStats {
 			const childOptions = Array.isArray(childrenOptions)
 				? childrenOptions[idx]
 				: childrenOptions;
+			if (typeof childOptions === "boolean") {
+				return stat.compilation.createStatsOptions(childOptions, context);
+			}
 			return stat.compilation.createStatsOptions(
 				{
 					...baseOptions,
@@ -93,18 +98,18 @@ class MultiStats {
 			);
 		});
 		return {
-			version: children.every(o => o.version),
-			hash: children.every(o => o.hash),
-			errorsCount: children.every(o => o.errorsCount),
-			warningsCount: children.every(o => o.warningsCount),
-			errors: children.every(o => o.errors),
-			warnings: children.every(o => o.warnings),
+			version: children.every((o) => o.version),
+			hash: children.every((o) => o.hash),
+			errorsCount: children.every((o) => o.errorsCount),
+			warningsCount: children.every((o) => o.warningsCount),
+			errors: children.every((o) => o.errors),
+			warnings: children.every((o) => o.warnings),
 			children
 		};
 	}
 
 	/**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @param {(string | boolean | MultiStatsOptions)=} options stats options
 	 * @returns {StatsCompilation} json output
 	 */
 	toJson(options) {
@@ -130,7 +135,7 @@ class MultiStats {
 			obj.version = obj.children[0].version;
 		}
 		if (childOptions.hash) {
-			obj.hash = obj.children.map(j => j.hash).join("");
+			obj.hash = obj.children.map((j) => j.hash).join("");
 		}
 		/**
 		 * @param {StatsCompilation} j stats error
@@ -179,7 +184,7 @@ class MultiStats {
 	}
 
 	/**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
+	 * @param {(string | boolean | MultiStatsOptions)=} options stats options
 	 * @returns {string} string output
 	 */
 	toString(options) {

package/lib/MultiWatching.js

@@ -67,7 +67,7 @@ class MultiWatching {
 			(watching, finishedCallback) => {
 				watching.close(finishedCallback);
 			},
-			err => {
+			(err) => {
 				this.compiler.hooks.watchClose.call();
 				if (typeof callback === "function") {
 					this.compiler.running = false;

package/lib/NoEmitOnErrorsPlugin.js

@@ -16,10 +16,10 @@ class NoEmitOnErrorsPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.shouldEmit.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.shouldEmit.tap(PLUGIN_NAME, (compilation) => {
 			if (compilation.getStats().hasErrors()) return false;
 		});
-		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			compilation.hooks.shouldRecord.tap(PLUGIN_NAME, () => {
 				if (compilation.getStats().hasErrors()) return false;
 			});

package/lib/NodeStuffPlugin.js

@@ -74,7 +74,7 @@ class NodeStuffPlugin {
 
 					if (localOptions.global !== false) {
 						const withWarning = localOptions.global === "warn";
-						parser.hooks.expression.for("global").tap(PLUGIN_NAME, expr => {
+						parser.hooks.expression.for("global").tap(PLUGIN_NAME, (expr) => {
 							const dep = new ConstDependency(
 								RuntimeGlobals.global,
 								/** @type {Range} */ (expr.range),
@@ -94,7 +94,7 @@ class NodeStuffPlugin {
 								);
 							}
 						});
-						parser.hooks.rename.for("global").tap(PLUGIN_NAME, expr => {
+						parser.hooks.rename.for("global").tap(PLUGIN_NAME, (expr) => {
 							const dep = new ConstDependency(
 								RuntimeGlobals.global,
 								/** @type {Range} */ (expr.range),
@@ -115,10 +115,11 @@ class NodeStuffPlugin {
 					const setModuleConstant = (expressionName, fn, warning) => {
 						parser.hooks.expression
 							.for(expressionName)
-							.tap(PLUGIN_NAME, expr => {
+							.tap(PLUGIN_NAME, (expr) => {
 								const dep = new CachedConstDependency(
 									JSON.stringify(fn(parser.state.module)),
-									/** @type {Range} */ (expr.range),
+									/** @type {Range} */
+									(expr.range),
 									expressionName
 								);
 								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
@@ -143,7 +144,7 @@ class NodeStuffPlugin {
 					const setUrlModuleConstant = (expressionName, fn) => {
 						parser.hooks.expression
 							.for(expressionName)
-							.tap(PLUGIN_NAME, expr => {
+							.tap(PLUGIN_NAME, (expr) => {
 								const dep = new ExternalModuleDependency(
 									"url",
 									[
@@ -186,14 +187,19 @@ class NodeStuffPlugin {
 									"__filename is a Node.js feature and isn't available in browsers."
 								);
 								break;
-							case "node-module":
+							case "node-module": {
+								const importMetaName =
+									/** @type {string} */
+									(compilation.outputOptions.importMetaName);
+
 								setUrlModuleConstant(
 									"__filename",
-									functionName => `${functionName}(import.meta.url)`
+									(functionName) => `${functionName}(${importMetaName}.url)`
 								);
 								break;
+							}
 							case true:
-								setModuleConstant("__filename", module =>
+								setModuleConstant("__filename", (module) =>
 									relative(
 										/** @type {InputFileSystem} */ (compiler.inputFileSystem),
 										context,
@@ -205,7 +211,7 @@ class NodeStuffPlugin {
 
 						parser.hooks.evaluateIdentifier
 							.for("__filename")
-							.tap(PLUGIN_NAME, expr => {
+							.tap(PLUGIN_NAME, (expr) => {
 								if (!parser.state.module) return;
 								const resource = parseResource(parser.state.module.resource);
 								return evaluateToString(resource.path)(expr);
@@ -223,15 +229,20 @@ class NodeStuffPlugin {
 									"__dirname is a Node.js feature and isn't available in browsers."
 								);
 								break;
-							case "node-module":
+							case "node-module": {
+								const importMetaName =
+									/** @type {string} */
+									(compilation.outputOptions.importMetaName);
+
 								setUrlModuleConstant(
 									"__dirname",
-									functionName =>
-										`${functionName}(import.meta.url + "/..").slice(0, -1)`
+									(functionName) =>
+										`${functionName}(${importMetaName}.url + "/..").slice(0, -1)`
 								);
 								break;
+							}
 							case true:
-								setModuleConstant("__dirname", module =>
+								setModuleConstant("__dirname", (module) =>
 									relative(
 										/** @type {InputFileSystem} */ (compiler.inputFileSystem),
 										context,
@@ -243,10 +254,11 @@ class NodeStuffPlugin {
 
 						parser.hooks.evaluateIdentifier
 							.for("__dirname")
-							.tap(PLUGIN_NAME, expr => {
+							.tap(PLUGIN_NAME, (expr) => {
 								if (!parser.state.module) return;
 								return evaluateToString(
-									/** @type {string} */ (parser.state.module.context)
+									/** @type {string} */
+									(parser.state.module.context)
 								)(expr);
 							});
 					}

package/lib/NormalModule.js

@@ -40,7 +40,8 @@ const {
 	compareLocations,
 	compareSelect,
 	concatComparators,
-	keepOriginalOrder
+	keepOriginalOrder,
+	sortWithSourceOrder
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
 const { createFakeHook } = require("./util/deprecation");
@@ -99,6 +100,8 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../declarations/WebpackOptions").HashFunction} HashFunction */
 /** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
+/** @typedef {import("./dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */
+/** @typedef {import("./dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /**
  * @template T
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook
@@ -160,17 +163,17 @@ const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
 	const { sourceRoot } = sourceMap;
 	/** @type {(source: string) => string} */
 	const mapper = !sourceRoot
-		? source => source
+		? (source) => source
 		: sourceRoot.endsWith("/")
-			? source =>
+			? (source) =>
 					source.startsWith("/")
 						? `${sourceRoot.slice(0, -1)}${source}`
 						: `${sourceRoot}${source}`
-			: source =>
+			: (source) =>
 					source.startsWith("/")
 						? `${sourceRoot}${source}`
 						: `${sourceRoot}/${source}`;
-	const newSources = sourceMap.sources.map(source =>
+	const newSources = sourceMap.sources.map((source) =>
 		contextifySourceUrl(context, mapper(source), associatedObjectForCache)
 	);
 	return {
@@ -185,7 +188,7 @@ const contextifySourceMap = (context, sourceMap, associatedObjectForCache) => {
  * @param {string | Buffer} input the input
  * @returns {string} the converted string
  */
-const asString = input => {
+const asString = (input) => {
 	if (Buffer.isBuffer(input)) {
 		return input.toString("utf8");
 	}
@@ -196,7 +199,7 @@ const asString = input => {
  * @param {string | Buffer} input the input
  * @returns {Buffer} the converted buffer
  */
-const asBuffer = input => {
+const asBuffer = (input) => {
 	if (!Buffer.isBuffer(input)) {
 		return Buffer.from(input, "utf8");
 	}
@@ -276,14 +279,14 @@ class NormalModule extends Module {
 				beforeParse: new SyncHook(["module"]),
 				beforeSnapshot: new SyncHook(["module"]),
 				// TODO webpack 6 deprecate
-				readResourceForScheme: new HookMap(scheme => {
+				readResourceForScheme: new HookMap((scheme) => {
 					const hook =
 						/** @type {NormalModuleCompilationHooks} */
 						(hooks).readResource.for(scheme);
 					return createFakeHook(
 						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
 							tap: (options, fn) =>
-								hook.tap(options, loaderContext =>
+								hook.tap(options, (loaderContext) =>
 									fn(
 										loaderContext.resource,
 										/** @type {NormalModule} */ (loaderContext._module)
@@ -298,7 +301,7 @@ class NormalModule extends Module {
 									)
 								),
 							tapPromise: (options, fn) =>
-								hook.tapPromise(options, loaderContext =>
+								hook.tapPromise(options, (loaderContext) =>
 									fn(
 										loaderContext.resource,
 										/** @type {NormalModule} */ (loaderContext._module)
@@ -596,19 +599,19 @@ class NormalModule extends Module {
 		 */
 		const getResolveContext = () => ({
 			fileDependencies: {
-				add: d =>
+				add: (d) =>
 					/** @type {LoaderContext<EXPECTED_ANY>} */ (
 						loaderContext
 					).addDependency(d)
 			},
 			contextDependencies: {
-				add: d =>
+				add: (d) =>
 					/** @type {LoaderContext<EXPECTED_ANY>} */ (
 						loaderContext
 					).addContextDependency(d)
 			},
 			missingDependencies: {
-				add: d =>
+				add: (d) =>
 					/** @type {LoaderContext<EXPECTED_ANY>} */ (
 						loaderContext
 					).addMissingDependency(d)
@@ -657,7 +660,7 @@ class NormalModule extends Module {
 			 * @param {HashFunction=} type type
 			 * @returns {Hash} hash
 			 */
-			createHash: type =>
+			createHash: (type) =>
 				createHash(
 					type ||
 						/** @type {HashFunction} */
@@ -671,7 +674,7 @@ class NormalModule extends Module {
 			 * @param {import("../declarations/LoaderContext").Schema=} schema schema
 			 * @returns {T} options
 			 */
-			getOptions: schema => {
+			getOptions: (schema) => {
 				const loader = this.getCurrentLoader(
 					/** @type {LoaderContext<EXPECTED_ANY>} */ (loaderContext)
 				);
@@ -713,7 +716,7 @@ class NormalModule extends Module {
 
 				return /** @type {T} */ (options);
 			},
-			emitWarning: warning => {
+			emitWarning: (warning) => {
 				if (!(warning instanceof Error)) {
 					warning = new NonErrorEmittedError(warning);
 				}
@@ -723,7 +726,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
-			emitError: error => {
+			emitError: (error) => {
 				if (!(error instanceof Error)) {
 					error = new NonErrorEmittedError(error);
 				}
@@ -733,7 +736,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
-			getLogger: name => {
+			getLogger: (name) => {
 				const currentLoader = this.getCurrentLoader(
 					/** @type {LoaderContext<EXPECTED_ANY>} */ (loaderContext)
 				);
@@ -799,7 +802,7 @@ class NormalModule extends Module {
 				);
 				assetsInfo.set(name, assetInfo);
 			},
-			addBuildDependency: dep => {
+			addBuildDependency: (dep) => {
 				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
 
 				if (buildInfo.buildDependencies === undefined) {
@@ -1187,7 +1190,7 @@ class NormalModule extends Module {
 
 		const hooks = NormalModule.getCompilationHooks(compilation);
 
-		return this._doBuild(options, compilation, resolver, fs, hooks, err => {
+		return this._doBuild(options, compilation, resolver, fs, hooks, (err) => {
 			// if we have an error mark module as failed and exit
 			if (err) {
 				this.markModuleAsErrored(err);
@@ -1199,9 +1202,9 @@ class NormalModule extends Module {
 			 * @param {Error} e error
 			 * @returns {void}
 			 */
-			const handleParseError = e => {
+			const handleParseError = (e) => {
 				const source = /** @type {Source} */ (this._source).source();
-				const loaders = this.loaders.map(item =>
+				const loaders = this.loaders.map((item) =>
 					contextify(
 						/** @type {string} */ (options.context),
 						item.loader,
@@ -1217,10 +1220,11 @@ class NormalModule extends Module {
 			const handleParseResult = () => {
 				this.dependencies.sort(
 					concatComparators(
-						compareSelect(a => a.loc, compareLocations),
+						compareSelect((a) => a.loc, compareLocations),
 						keepOriginalOrder(this.dependencies)
 					)
 				);
+				sortWithSourceOrder(this.dependencies, new WeakMap());
 				this._initBuildHash(compilation);
 				this._lastSuccessfulBuildMeta =
 					/** @type {BuildMeta} */
@@ -1248,7 +1252,7 @@ class NormalModule extends Module {
 				/**
 				 * @param {LazySet<string>} deps deps
 				 */
-				const checkDependencies = deps => {
+				const checkDependencies = (deps) => {
 					for (const dep of deps) {
 						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
 							if (nonAbsoluteDependencies === undefined) {