webpack 5.100.0 → 5.100.2

package/lib/stats/DefaultStatsPresetPlugin.js

@@ -182,7 +182,7 @@ const AUTO_FOR_TO_STRING = ({ all }, { forToString }) => {
 /** @typedef {keyof NormalizedStatsOptions} DefaultsKeys */
 /** @typedef {{ [Key in DefaultsKeys]: (options: Partial<NormalizedStatsOptions>, context: CreateStatsOptionsContext, compilation: Compilation) => NormalizedStatsOptions[Key] | RequestShortener }} Defaults */
 
-/** @type {Partial<Defaults>} */
+/** @type {Defaults} */
 const DEFAULTS = {
 	context: (options, context, compilation) => compilation.compiler.context,
 	requestShortener: (options, context, compilation) =>
@@ -307,9 +307,9 @@ const normalizeFilter = item => {
 };
 
 /** @typedef {keyof (KnownNormalizedStatsOptions | StatsOptions)} NormalizerKeys */
-/** @typedef {{ [Key in NormalizerKeys]: (value: StatsOptions[Key]) => KnownNormalizedStatsOptions[Key] }} Normalizers */
+/** @typedef {{ [Key in NormalizerKeys]?: (value: StatsOptions[Key]) => KnownNormalizedStatsOptions[Key] }} Normalizers */
 
-/** @type {Partial<Normalizers>} */
+/** @type {Normalizers} */
 const NORMALIZER = {
 	excludeModules: value => {
 		if (!Array.isArray(value)) {
@@ -391,18 +391,16 @@ class DefaultStatsPresetPlugin {
 			compilation.hooks.statsNormalize.tap(PLUGIN_NAME, (options, context) => {
 				for (const key of Object.keys(DEFAULTS)) {
 					if (options[key] === undefined) {
-						options[key] =
-							/** @type {Defaults[DefaultsKeys]} */
-							(DEFAULTS[/** @type {DefaultsKeys} */ (key)])(
-								options,
-								context,
-								compilation
-							);
+						options[key] = DEFAULTS[/** @type {DefaultsKeys} */ (key)](
+							options,
+							context,
+							compilation
+						);
 					}
 				}
 				for (const key of Object.keys(NORMALIZER)) {
 					options[key] =
-						/** @type {TODO} */
+						/** @type {NonNullable<Normalizers[keyof Normalizers]>} */
 						(NORMALIZER[/** @type {NormalizerKeys} */ (key)])(options[key]);
 				}
 			});

package/lib/stats/StatsFactory.js

@@ -121,7 +121,8 @@ class StatsFactory {
 			getItemFactory: new HookMap(() => new SyncBailHook(["item", "context"]))
 		});
 		const hooks = this.hooks;
-		this._caches = /** @type {TODO} */ ({});
+		this._caches =
+			/** @type {{ [Key in keyof StatsFactoryHooks]: Map<string, SyncBailHook<EXPECTED_ANY, EXPECTED_ANY>[]> }} */ ({});
 		for (const key of Object.keys(hooks)) {
 			this._caches[/** @type {keyof StatsFactoryHooks} */ (key)] = new Map();
 		}

package/lib/stats/StatsPrinter.js

@@ -102,9 +102,7 @@ class StatsPrinter {
 			print: new HookMap(() => new SyncBailHook(["object", "context"])),
 			result: new HookMap(() => new SyncWaterfallHook(["result", "context"]))
 		});
-		/**
-		 * @type {TODO}
-		 */
+		/** @type {Map<StatsPrintHooks[keyof StatsPrintHooks], Map<string, import("tapable").Hook<EXPECTED_ANY, EXPECTED_ANY>[]>>} */
 		this._levelHookCache = new Map();
 		this._inPrint = false;
 	}
@@ -126,7 +124,7 @@ class StatsPrinter {
 		}
 		const cacheEntry = cache.get(type);
 		if (cacheEntry !== undefined) {
-			return cacheEntry;
+			return /** @type {H[]} */ (cacheEntry);
 		}
 		/** @type {H[]} */
 		const hooks = [];
@@ -146,7 +144,7 @@ class StatsPrinter {
 	 * @private
 	 * @template {StatsPrintHooks[keyof StatsPrintHooks]} HM
 	 * @template {HM extends HookMap<infer H> ? H : never} H
-	 * @template {H extends import("tapable").Hook<any, infer R> ? R : never} R
+	 * @template {H extends import("tapable").Hook<EXPECTED_ANY, infer R> ? R : never} R
 	 * @param {HM} hookMap hook map
 	 * @param {string} type type
 	 * @param {(hooK: H) => R | undefined | void} fn fn

package/lib/util/cleverMerge.js

@@ -85,32 +85,43 @@ const cachedSetProperty = (obj, property, value) => {
 };
 
 /**
- * @template V
- * @typedef {Map<string, V | undefined>} ByValues
+ * @typedef {Map<string, EXPECTED_ANY>} ByValues
  */
 
 /**
+ * @template T
  * @typedef {object} ObjectParsedPropertyEntry
- * @property {TODO | undefined} base base value
+ * @property {T[keyof T] | undefined} base base value
  * @property {string | undefined} byProperty the name of the selector property
- * @property {ByValues<TODO>} byValues value depending on selector property, merged with base
+ * @property {ByValues | undefined} byValues value depending on selector property, merged with base
  */
 
 /** @typedef {(function(...EXPECTED_ANY): object) & { [DYNAMIC_INFO]: [DynamicFunction, object] }} DynamicFunction */
 
 /**
+ * @template {object} T
+ * @typedef {Map<keyof T, ObjectParsedPropertyEntry<T>>} ParsedObjectStatic
+ */
+
+/**
+ * @template {object} T
+ * @typedef {{ byProperty: string, fn: DynamicFunction }} ParsedObjectDynamic
+ */
+
+/**
+ * @template {object} T
  * @typedef {object} ParsedObject
- * @property {Map<string, ObjectParsedPropertyEntry>} static static properties (key is property name)
- * @property {{ byProperty: string, fn: DynamicFunction } | undefined} dynamic dynamic part
+ * @property {ParsedObjectStatic<T>} static static properties (key is property name)
+ * @property {ParsedObjectDynamic<T> | undefined} dynamic dynamic part
  */
 
-/** @type {WeakMap<EXPECTED_OBJECT, ParsedObject>} */
+/** @type {WeakMap<EXPECTED_OBJECT, ParsedObject<EXPECTED_ANY>>} */
 const parseCache = new WeakMap();
 
 /**
  * @template {object} T
  * @param {T} obj the object
- * @returns {ParsedObject} parsed object
+ * @returns {ParsedObject<T>} parsed object
  */
 const cachedParseObject = obj => {
 	const entry = parseCache.get(/** @type {EXPECTED_OBJECT} */ (obj));
@@ -120,18 +131,21 @@ const cachedParseObject = obj => {
 	return result;
 };
 
+/** @typedef {{ [p: string]: { [p: string]: EXPECTED_ANY } } | DynamicFunction} ByObject */
+
 /**
  * @template {object} T
- * @template V
  * @param {T} obj the object
- * @returns {ParsedObject} parsed object
+ * @returns {ParsedObject<T>} parsed object
  */
 const parseObject = obj => {
+	/** @type {ParsedObjectStatic<T>} */
 	const info = new Map();
+	/** @type {ParsedObjectDynamic<T> | undefined} */
 	let dynamicInfo;
 	/**
-	 * @param {string} p path
-	 * @returns {Partial<ObjectParsedPropertyEntry>} object parsed property entry
+	 * @param {keyof T} p path
+	 * @returns {Partial<ObjectParsedPropertyEntry<T>>} object parsed property entry
 	 */
 	const getInfo = p => {
 		const entry = info.get(p);
@@ -144,37 +158,35 @@ const parseObject = obj => {
 		info.set(p, newEntry);
 		return newEntry;
 	};
-	for (const key of Object.keys(obj)) {
-		if (key.startsWith("by")) {
-			const byProperty = /** @type {keyof T} */ (key);
-			const byObj = /** @type {TODO} */ (obj[byProperty]);
+	for (const key_ of Object.keys(obj)) {
+		const key = /** @type {keyof T} */ (key_);
+		if (typeof key === "string" && key.startsWith("by")) {
+			const byProperty = key;
+			const byObj = /** @type {ByObject} */ (obj[byProperty]);
 			if (typeof byObj === "object") {
 				for (const byValue of Object.keys(byObj)) {
 					const obj = byObj[/** @type {keyof (keyof T)} */ (byValue)];
 					for (const key of Object.keys(obj)) {
-						const entry = getInfo(key);
+						const entry = getInfo(/** @type {keyof T} */ (key));
 						if (entry.byProperty === undefined) {
-							entry.byProperty = /** @type {string} */ (byProperty);
+							entry.byProperty = byProperty;
 							entry.byValues = new Map();
 						} else if (entry.byProperty !== byProperty) {
 							throw new Error(
 								`${/** @type {string} */ (byProperty)} and ${entry.byProperty} for a single property is not supported`
 							);
 						}
-						/** @type {ByValues<V>} */
-						(entry.byValues).set(
-							byValue,
-							obj[/** @type {keyof (keyof T)} */ (key)]
-						);
+						/** @type {ByValues} */
+						(entry.byValues).set(byValue, obj[key]);
 						if (byValue === "default") {
 							for (const otherByValue of Object.keys(byObj)) {
 								if (
 									!(
-										/** @type {ByValues<V>} */
+										/** @type {ByValues} */
 										(entry.byValues).has(otherByValue)
 									)
 								) {
-									/** @type {ByValues<V>} */
+									/** @type {ByValues} */
 									(entry.byValues).set(otherByValue, undefined);
 								}
 							}
@@ -194,11 +206,11 @@ const parseObject = obj => {
 				}
 			} else {
 				const entry = getInfo(key);
-				entry.base = obj[/** @type {keyof T} */ (key)];
+				entry.base = obj[key];
 			}
 		} else {
 			const entry = getInfo(key);
-			entry.base = obj[/** @type {keyof T} */ (key)];
+			entry.base = obj[key];
 		}
 	}
 	return {
@@ -209,8 +221,8 @@ const parseObject = obj => {
 
 /**
  * @template {object} T
- * @param {Map<string, ObjectParsedPropertyEntry>} info static properties (key is property name)
- * @param {{ byProperty: string, fn: (...args: EXPECTED_ANY[]) => T } | undefined} dynamicInfo dynamic part
+ * @param {ParsedObjectStatic<T>} info static properties (key is property name)
+ * @param {{ byProperty: string, fn: DynamicFunction } | undefined} dynamicInfo dynamic part
  * @returns {T} the object
  */
 const serializeObject = (info, dynamicInfo) => {
@@ -221,7 +233,7 @@ const serializeObject = (info, dynamicInfo) => {
 			const byProperty = /** @type {keyof T} */ (entry.byProperty);
 			const byObj = (obj[byProperty] =
 				obj[byProperty] || /** @type {TODO} */ ({}));
-			for (const byValue of entry.byValues.keys()) {
+			for (const byValue of /** @type {ByValues} */ (entry.byValues).keys()) {
 				byObj[byValue] = byObj[byValue] || {};
 			}
 		}
@@ -236,7 +248,11 @@ const serializeObject = (info, dynamicInfo) => {
 			const byObj = (obj[byProperty] =
 				obj[byProperty] || /** @type {TODO} */ ({}));
 			for (const byValue of Object.keys(byObj)) {
-				const value = getFromByValues(entry.byValues, byValue);
+				const value = getFromByValues(
+					/** @type {ByValues} */
+					(entry.byValues),
+					byValue
+				);
 				if (value !== undefined) byObj[byValue][key] = value;
 			}
 		}
@@ -317,7 +333,7 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 		const fnInfo = fn[DYNAMIC_INFO];
 		if (fnInfo) {
 			second =
-				/** @type {TODO} */
+				/** @type {O} */
 				(
 					internalCaching
 						? cachedCleverMerge(fnInfo[1], second)
@@ -343,10 +359,12 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 		? cachedParseObject(second)
 		: parseObject(second);
 	const { static: secondInfo, dynamic: secondDynamicInfo } = secondObject;
-	/** @type {Map<string, ObjectParsedPropertyEntry>} */
 	const resultInfo = new Map();
 	for (const [key, firstEntry] of firstInfo) {
-		const secondEntry = secondInfo.get(key);
+		const secondEntry = secondInfo.get(
+			/** @type {keyof (T | O)} */
+			(key)
+		);
 		const entry =
 			secondEntry !== undefined
 				? mergeEntries(firstEntry, secondEntry, internalCaching)
@@ -354,7 +372,7 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 		resultInfo.set(key, entry);
 	}
 	for (const [key, secondEntry] of secondInfo) {
-		if (!firstInfo.has(key)) {
+		if (!firstInfo.has(/** @type {keyof (T | O)} */ (key))) {
 			resultInfo.set(key, secondEntry);
 		}
 	}
@@ -362,10 +380,11 @@ const _cleverMerge = (first, second, internalCaching = false) => {
 };
 
 /**
- * @param {ObjectParsedPropertyEntry} firstEntry a
- * @param {ObjectParsedPropertyEntry} secondEntry b
+ * @template T, O
+ * @param {ObjectParsedPropertyEntry<T>} firstEntry a
+ * @param {ObjectParsedPropertyEntry<O>} secondEntry b
  * @param {boolean} internalCaching should parsing of objects and nested merges be cached
- * @returns {ObjectParsedPropertyEntry} new entry
+ * @returns {ObjectParsedPropertyEntry<TODO>} new entry
  */
 const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 	switch (getValueType(secondEntry.base)) {
@@ -391,8 +410,14 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				// = first.base + (first.byProperty + second.byProperty)
 				// need to merge first and second byValues
 				const newByValues = new Map(firstEntry.byValues);
-				for (const [key, value] of secondEntry.byValues) {
-					const firstValue = getFromByValues(firstEntry.byValues, key);
+				for (const [key, value] of /** @type {ByValues} */ (
+					secondEntry.byValues
+				)) {
+					const firstValue = getFromByValues(
+						/** @type {ByValues} */
+						(firstEntry.byValues),
+						key
+					);
 					newByValues.set(
 						key,
 						mergeSingleValue(firstValue, value, internalCaching)
@@ -409,11 +434,15 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				// The simple case
 				// = (first.base + second.base) + second.byProperty
 				return {
-					base: mergeSingleValue(
-						firstEntry.base,
-						secondEntry.base,
-						internalCaching
-					),
+					base:
+						/** @type {T[keyof T] & O[keyof O]} */
+						(
+							mergeSingleValue(
+								firstEntry.base,
+								secondEntry.base,
+								internalCaching
+							)
+						),
 					byProperty: secondEntry.byProperty,
 					byValues: secondEntry.byValues
 				};
@@ -427,10 +456,12 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			if (
-				[...firstEntry.byValues.values()].every(value => {
-					const type = getValueType(value);
-					return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
-				})
+				[.../** @type {ByValues} */ (firstEntry.byValues).values()].every(
+					value => {
+						const type = getValueType(value);
+						return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
+					}
+				)
 			) {
 				// = (first.base + second.base) + ((first.byProperty + second.base) + second.byProperty)
 				newBase = mergeSingleValue(
@@ -458,7 +489,9 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 				);
 			}
 			const newByValues = new Map(intermediateByValues);
-			for (const [key, value] of secondEntry.byValues) {
+			for (const [key, value] of /** @type {ByValues} */ (
+				secondEntry.byValues
+			)) {
 				const firstValue = getFromByValues(intermediateByValues, key);
 				newByValues.set(
 					key,
@@ -476,7 +509,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 
 /**
  * @template V
- * @param {ByValues<V>} byValues all values
+ * @param {ByValues} byValues all values
  * @param {string} key value of the selector
  * @returns {V | undefined} value
  */

package/lib/util/comparators.js

@@ -13,9 +13,18 @@ const { compareRuntime } = require("./runtime");
 /** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
+/** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */
+/** @typedef {import("../dependencies/HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 
+/**
+ * @typedef {object} DependencySourceOrder
+ * @property {number} main the main source order
+ * @property {number} sub the sub source order
+ */
+
 /**
  * @template T
  * @typedef {(a: T, b: T) => -1 | 0 | 1} Comparator
@@ -497,6 +506,95 @@ const compareChunksNatural = chunkGraph => {
 	);
 };
 
+/**
+ * For HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency, we should prioritize import order to match the behavior of running modules directly in a JS engine without a bundler.
+ * For other types like ConstDependency, we can instead prioritize usage order.
+ * https://github.com/webpack/webpack/pull/19686
+ * @param {Dependency[]} dependencies dependencies
+ * @param {WeakMap<Dependency, DependencySourceOrder>} dependencySourceOrderMap dependency source order map
+ * @returns {void}
+ */
+const sortWithSourceOrder = (dependencies, dependencySourceOrderMap) => {
+	/**
+	 * @param {Dependency} dep dependency
+	 * @returns {number} source order
+	 */
+	const getSourceOrder = dep => {
+		if (dependencySourceOrderMap.has(dep)) {
+			const { main } = /** @type {DependencySourceOrder} */ (
+				dependencySourceOrderMap.get(dep)
+			);
+			return main;
+		}
+		return /** @type { HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */ (
+			dep
+		).sourceOrder;
+	};
+
+	/**
+	 * If the sourceOrder is a number, it means the dependency needs to be sorted.
+	 * @param {number | undefined} sourceOrder sourceOrder
+	 * @returns {boolean} needReSort
+	 */
+	const needReSort = sourceOrder => {
+		if (typeof sourceOrder === "number") {
+			return true;
+		}
+		return false;
+	};
+
+	// Extract dependencies with sourceOrder and sort them
+	const withSourceOrder = [];
+
+	// First pass: collect dependencies with sourceOrder
+	for (let i = 0; i < dependencies.length; i++) {
+		const dep = dependencies[i];
+		const sourceOrder = getSourceOrder(dep);
+
+		if (needReSort(sourceOrder)) {
+			withSourceOrder.push({ dep, sourceOrder, originalIndex: i });
+		}
+	}
+
+	if (withSourceOrder.length <= 1) {
+		return;
+	}
+
+	// Sort dependencies with sourceOrder
+	withSourceOrder.sort((a, b) => {
+		// Handle both dependencies in map case
+		if (
+			dependencySourceOrderMap.has(a.dep) &&
+			dependencySourceOrderMap.has(b.dep)
+		) {
+			const { main: mainA, sub: subA } = /** @type {DependencySourceOrder} */ (
+				dependencySourceOrderMap.get(a.dep)
+			);
+			const { main: mainB, sub: subB } = /** @type {DependencySourceOrder} */ (
+				dependencySourceOrderMap.get(b.dep)
+			);
+			if (mainA === mainB) {
+				return compareNumbers(subA, subB);
+			}
+			return compareNumbers(mainA, mainB);
+		}
+
+		return compareNumbers(a.sourceOrder, b.sourceOrder);
+	});
+
+	// Second pass: build result array
+	let sortedIndex = 0;
+	for (let i = 0; i < dependencies.length; i++) {
+		const dep = dependencies[i];
+		const sourceOrder = getSourceOrder(dep);
+
+		if (needReSort(sourceOrder)) {
+			dependencies[i] = withSourceOrder[sortedIndex].dep;
+			sortedIndex++;
+		}
+	}
+};
+
 module.exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
 /** @type {ParameterizedComparator<ChunkGraph, Chunk>} */
 module.exports.compareChunks =
@@ -548,3 +646,4 @@ module.exports.compareStringsNumeric = compareStringsNumeric;
 module.exports.concatComparators = concatComparators;
 
 module.exports.keepOriginalOrder = keepOriginalOrder;
+module.exports.sortWithSourceOrder = sortWithSourceOrder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.100.0",
+  "version": "5.100.2",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",
@@ -112,13 +112,13 @@
     "@babel/preset-react": "^7.27.1",
     "@codspeed/tinybench-plugin": "^4.0.1",
     "@eslint/js": "^9.29.0",
-    "@eslint/markdown": "^6.6.0",
+    "@eslint/markdown": "^7.0.0",
     "@stylistic/eslint-plugin": "^5.0.0",
     "@types/glob-to-regexp": "^0.4.4",
     "@types/graceful-fs": "^4.1.9",
     "@types/jest": "^30.0.0",
     "@types/mime-types": "^2.1.4",
-    "@types/node": "^24.0.3",
+    "@types/node": "^24.0.13",
     "@types/xxhashjs": "^0.2.4",
     "assemblyscript": "^0.28.2",
     "babel-loader": "^10.0.0",
@@ -179,10 +179,10 @@
     "strip-ansi": "^6.0.0",
     "style-loader": "^4.0.0",
     "terser": "^5.43.1",
-    "three": "^0.177.0",
+    "three": "^0.178.0",
     "tinybench": "^4.0.1",
     "toml": "^3.0.0",
-    "tooling": "webpack/tooling#v1.24.0",
+    "tooling": "webpack/tooling#v1.24.3",
     "ts-loader": "^9.5.1",
     "typescript": "^5.8.2",
     "url-loader": "^4.1.0",