webpack 5.100.1 → 5.101.0

package/lib/url/URLParserPlugin.js

@@ -33,7 +33,7 @@ const PLUGIN_NAME = "URLParserPlugin";
  * @param {NormalModule} module module
  * @returns {URL} file url
  */
-const getUrl = module => pathToFileURL(module.resource);
+const getUrl = (module) => pathToFileURL(module.resource);
 
 /**
  * @param {Parser} parser parser parser
@@ -108,7 +108,7 @@ class URLParserPlugin {
 		const relative = this.options.url === "relative";
 
 		parser.hooks.canRename.for("URL").tap(PLUGIN_NAME, approve);
-		parser.hooks.evaluateNewExpression.for("URL").tap(PLUGIN_NAME, expr => {
+		parser.hooks.evaluateNewExpression.for("URL").tap(PLUGIN_NAME, (expr) => {
 			const evaluatedExpr = getEvaluatedExpr(expr, parser);
 			const request = evaluatedExpr && evaluatedExpr.asString();
 
@@ -119,7 +119,7 @@ class URLParserPlugin {
 				.setString(url.toString())
 				.setRange(/** @type {Range} */ (expr.range));
 		});
-		parser.hooks.new.for("URL").tap(PLUGIN_NAME, _expr => {
+		parser.hooks.new.for("URL").tap(PLUGIN_NAME, (_expr) => {
 			const expr = /** @type {NewExpressionNode} */ (_expr);
 			const { options: importOptions, errors: commentErrors } =
 				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
@@ -185,7 +185,7 @@ class URLParserPlugin {
 				);
 				dep.loc = /** @type {DependencyLocation} */ (expr.loc);
 				parser.state.current.addDependency(dep);
-				InnerGraph.onUsage(parser.state, e => (dep.usedByExports = e));
+				InnerGraph.onUsage(parser.state, (e) => (dep.usedByExports = e));
 				return true;
 			}
 
@@ -248,7 +248,7 @@ class URLParserPlugin {
 			parser.state.current.addDependency(dep);
 			return true;
 		});
-		parser.hooks.isPure.for("NewExpression").tap(PLUGIN_NAME, _expr => {
+		parser.hooks.isPure.for("NewExpression").tap(PLUGIN_NAME, (_expr) => {
 			const expr = /** @type {NewExpressionNode} */ (_expr);
 			const { callee } = expr;
 			if (callee.type !== "Identifier") return;

package/lib/util/AsyncQueue.js

@@ -80,7 +80,7 @@ class AsyncQueue {
 		this._processor = processor;
 		this._getKey =
 			getKey ||
-			/** @type {getKey<T, K>} */ (item => /** @type {T & K} */ (item));
+			/** @type {getKey<T, K>} */ ((item) => /** @type {T & K} */ (item));
 		/** @type {Map<K, AsyncQueueEntry<T, K, R>>} */
 		this._entries = new Map();
 		/** @type {ArrayQueue<AsyncQueueEntry<T, K, R>>} */
@@ -138,7 +138,7 @@ class AsyncQueue {
 	 */
 	add(item, callback) {
 		if (this._stopped) return callback(new WebpackError("Queue was stopped"));
-		this.hooks.beforeAdd.callAsync(item, err => {
+		this.hooks.beforeAdd.callAsync(item, (err) => {
 			if (err) {
 				callback(
 					makeWebpackError(err, `AsyncQueue(${this._name}).hooks.beforeAdd`)
@@ -327,7 +327,7 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_startProcessing(entry) {
-		this.hooks.beforeStart.callAsync(entry.item, err => {
+		this.hooks.beforeStart.callAsync(entry.item, (err) => {
 			if (err) {
 				this._handleResult(
 					entry,
@@ -356,7 +356,7 @@ class AsyncQueue {
 	 * @returns {void}
 	 */
 	_handleResult(entry, err, result) {
-		this.hooks.result.callAsync(entry.item, err, result, hookError => {
+		this.hooks.result.callAsync(entry.item, err, result, (hookError) => {
 			const error = hookError
 				? makeWebpackError(hookError, `AsyncQueue(${this._name}).hooks.result`)
 				: err;

package/lib/util/IterableHelpers.js

@@ -10,7 +10,7 @@
  * @param {Iterable<T>} set a set
  * @returns {T | undefined} last item
  */
-const last = set => {
+const last = (set) => {
 	let last;
 	for (const item of set) last = item;
 	return last;
@@ -34,7 +34,7 @@ const someInIterable = (iterable, filter) => {
  * @param {Iterable<T>} iterable an iterable
  * @returns {number} count of items
  */
-const countIterable = iterable => {
+const countIterable = (iterable) => {
 	let i = 0;
 	for (const _ of iterable) i++;
 	return i;

package/lib/util/LazyBucketSortedSet.js

@@ -162,7 +162,7 @@ class LazyBucketSortedSet {
 	 */
 	startUpdate(item) {
 		if (this._unsortedItems.has(item)) {
-			return remove => {
+			return (remove) => {
 				if (remove) {
 					this._unsortedItems.delete(item);
 					this.size--;
@@ -172,7 +172,7 @@ class LazyBucketSortedSet {
 		const key = this._getKey(item);
 		if (this._leaf) {
 			const oldEntry = /** @type {SortableSet<T>} */ (this._map.get(key));
-			return remove => {
+			return (remove) => {
 				if (remove) {
 					this.size--;
 					oldEntry.delete(item);
@@ -198,7 +198,7 @@ class LazyBucketSortedSet {
 			/** @type {LazyBucketSortedSet<T, K>} */
 			(this._map.get(key));
 		const finishUpdate = oldEntry.startUpdate(item);
-		return remove => {
+		return (remove) => {
 			if (remove) {
 				this.size--;
 				finishUpdate(true);

package/lib/util/SetHelpers.js

@@ -11,7 +11,7 @@
  * @param {Set<T>[]} sets an array of sets being checked for shared elements
  * @returns {Set<T>} returns a new Set containing the intersecting items
  */
-const intersect = sets => {
+const intersect = (sets) => {
 	if (sets.length === 0) return new Set();
 	if (sets.length === 1) return new Set(sets[0]);
 	let minSize = Infinity;
@@ -68,7 +68,7 @@ const find = (set, fn) => {
  * @param {Set<T> | ReadonlySet<T>} set a set
  * @returns {T | undefined} first item
  */
-const first = set => {
+const first = (set) => {
 	const entry = set.values().next();
 	return entry.done ? undefined : entry.value;
 };

package/lib/util/StackedCacheMap.js

@@ -124,7 +124,7 @@ class StackedCacheMap {
 	 * @returns {Iterator<[K, V]>} iterator
 	 */
 	[Symbol.iterator]() {
-		const iterators = this.stack.map(map => map[Symbol.iterator]());
+		const iterators = this.stack.map((map) => map[Symbol.iterator]());
 		let current = this.map[Symbol.iterator]();
 		return {
 			next() {

package/lib/util/StackedMap.js

@@ -24,7 +24,7 @@ const UNDEFINED_MARKER = Symbol("undefined");
  * @param {[K, InternalCell<V>]} pair the internal cell
  * @returns {[K, Cell<V>]} its “safe” representation
  */
-const extractPair = pair => {
+const extractPair = (pair) => {
 	const key = pair[0];
 	const val = pair[1];
 	if (val === UNDEFINED_MARKER || val === TOMBSTONE) {

package/lib/util/TupleSet.js

@@ -125,7 +125,7 @@ class TupleSet {
 		 * @param {MapIterator<[T, InnerMap<T, V> | Set<V>]>} it iterator
 		 * @returns {boolean} result
 		 */
-		const next = it => {
+		const next = (it) => {
 			const result = it.next();
 			if (result.done) {
 				if (iteratorStack.length === 0) return false;

package/lib/util/WeakTupleMap.js

@@ -21,7 +21,7 @@
  * @param {EXPECTED_ANY} thing thing
  * @returns {boolean} true if is weak
  */
-const isWeakKey = thing => typeof thing === "object" && thing !== null;
+const isWeakKey = (thing) => typeof thing === "object" && thing !== null;
 
 /**
  * @template {unknown[]} T

package/lib/util/cleverMerge.js

@@ -123,7 +123,7 @@ const parseCache = new WeakMap();
  * @param {T} obj the object
  * @returns {ParsedObject<T>} parsed object
  */
-const cachedParseObject = obj => {
+const cachedParseObject = (obj) => {
 	const entry = parseCache.get(/** @type {EXPECTED_OBJECT} */ (obj));
 	if (entry !== undefined) return entry;
 	const result = parseObject(obj);
@@ -138,7 +138,7 @@ const cachedParseObject = obj => {
  * @param {T} obj the object
  * @returns {ParsedObject<T>} parsed object
  */
-const parseObject = obj => {
+const parseObject = (obj) => {
 	/** @type {ParsedObjectStatic<T>} */
 	const info = new Map();
 	/** @type {ParsedObjectDynamic<T> | undefined} */
@@ -147,7 +147,7 @@ const parseObject = obj => {
 	 * @param {keyof T} p path
 	 * @returns {Partial<ObjectParsedPropertyEntry<T>>} object parsed property entry
 	 */
-	const getInfo = p => {
+	const getInfo = (p) => {
 		const entry = info.get(p);
 		if (entry !== undefined) return entry;
 		const newEntry = {
@@ -275,7 +275,7 @@ const VALUE_TYPE_DELETE = 4;
  * @param {T} value a single value
  * @returns {VALUE_TYPE_UNDEFINED | VALUE_TYPE_ATOM | VALUE_TYPE_ARRAY_EXTEND | VALUE_TYPE_OBJECT | VALUE_TYPE_DELETE} value type
  */
-const getValueType = value => {
+const getValueType = (value) => {
 	if (value === undefined) {
 		return VALUE_TYPE_UNDEFINED;
 	} else if (value === DELETE) {
@@ -457,7 +457,7 @@ const mergeEntries = (firstEntry, secondEntry, internalCaching) => {
 			}
 			if (
 				[.../** @type {ByValues} */ (firstEntry.byValues).values()].every(
-					value => {
+					(value) => {
 						const type = getValueType(value);
 						return type === VALUE_TYPE_ATOM || type === VALUE_TYPE_DELETE;
 					}
@@ -555,7 +555,7 @@ const mergeSingleValue = (a, b, internalCaching) => {
 				case VALUE_TYPE_UNDEFINED:
 					return b;
 				case VALUE_TYPE_DELETE:
-					return /** @type {B[]} */ (b).filter(item => item !== "...");
+					return /** @type {B[]} */ (b).filter((item) => item !== "...");
 				case VALUE_TYPE_ARRAY_EXTEND: {
 					/** @type {(A | B)[]} */
 					const newArray = [];
@@ -571,7 +571,7 @@ const mergeSingleValue = (a, b, internalCaching) => {
 					return newArray;
 				}
 				case VALUE_TYPE_OBJECT:
-					return /** @type {(A | B)[]} */ (b).map(item =>
+					return /** @type {(A | B)[]} */ (b).map((item) =>
 						item === "..." ? /** @type {A} */ (a) : item
 					);
 				default:
@@ -618,7 +618,7 @@ const removeOperations = (obj, keysToKeepOriginalValue = []) => {
 					/** @type {T[keyof T]} */
 					(
 						/** @type {EXPECTED_ANY[]} */
-						(value).filter(i => i !== "...")
+						(value).filter((i) => i !== "...")
 					);
 				break;
 			default:

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
@@ -37,10 +46,10 @@ const { compareRuntime } = require("./runtime");
  * @param {RawParameterizedComparator<TArg, T>} fn comparator with argument
  * @returns {ParameterizedComparator<TArg, T>} comparator
  */
-const createCachedParameterizedComparator = fn => {
+const createCachedParameterizedComparator = (fn) => {
 	/** @type {WeakMap<EXPECTED_OBJECT, Comparator<T>>} */
 	const map = new WeakMap();
-	return arg => {
+	return (arg) => {
 		const cachedResult = map.get(/** @type {EXPECTED_OBJECT} */ (arg));
 		if (cachedResult !== undefined) return cachedResult;
 		/**
@@ -73,7 +82,7 @@ const compareIds = (a, b) => {
  * @param {Comparator<T>} elementComparator comparator for elements
  * @returns {Comparator<Iterable<T>>} comparator for iterables of elements
  */
-const compareIterables = elementComparator => {
+const compareIterables = (elementComparator) => {
 	const cacheEntry = compareIteratorsCache.get(elementComparator);
 	if (cacheEntry !== undefined) return cacheEntry;
 	/**
@@ -459,7 +468,7 @@ const compareIteratorsCache = new WeakMap();
  * @param {Iterable<T>} iterable original ordered list
  * @returns {Comparator<T>} comparator
  */
-const keepOriginalOrder = iterable => {
+const keepOriginalOrder = (iterable) => {
 	/** @type {Map<T, number>} */
 	const map = new Map();
 	let i = 0;
@@ -477,26 +486,115 @@ const keepOriginalOrder = iterable => {
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @returns {Comparator<Chunk>} comparator
  */
-const compareChunksNatural = chunkGraph => {
+const compareChunksNatural = (chunkGraph) => {
 	const cmpFn = module.exports.compareModulesById(chunkGraph);
 	const cmpIterableFn = compareIterables(cmpFn);
 	return concatComparators(
 		compareSelect(
-			chunk => /** @type {string|number} */ (chunk.name),
+			(chunk) => /** @type {string|number} */ (chunk.name),
 			compareIds
 		),
-		compareSelect(chunk => chunk.runtime, compareRuntime),
+		compareSelect((chunk) => chunk.runtime, compareRuntime),
 		compareSelect(
 			/**
 			 * @param {Chunk} chunk a chunk
 			 * @returns {Iterable<Module>} modules
 			 */
-			chunk => chunkGraph.getOrderedChunkModulesIterable(chunk, cmpFn),
+			(chunk) => chunkGraph.getOrderedChunkModulesIterable(chunk, cmpFn),
 			cmpIterableFn
 		)
 	);
 };
 
+/**
+ * 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/lib/util/compileBooleanMatcher.js

@@ -9,13 +9,13 @@
  * @param {string} str string
  * @returns {string} quoted meta
  */
-const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
+const quoteMeta = (str) => str.replace(/[-[\]\\/{}()*+?.^$|]/g, "\\$&");
 
 /**
  * @param {string} str string
  * @returns {string} string
  */
-const toSimpleString = str => {
+const toSimpleString = (str) => {
 	if (`${Number(str)}` === str) {
 		return str;
 	}
@@ -26,9 +26,9 @@ const toSimpleString = str => {
  * @param {Record<string | number, boolean>} map value map
  * @returns {boolean | ((value: string) => string)} true/false, when unconditionally true/false, or a template function to determine the value at runtime
  */
-const compileBooleanMatcher = map => {
-	const positiveItems = Object.keys(map).filter(i => map[i]);
-	const negativeItems = Object.keys(map).filter(i => !map[i]);
+const compileBooleanMatcher = (map) => {
+	const positiveItems = Object.keys(map).filter((i) => map[i]);
+	const negativeItems = Object.keys(map).filter((i) => !map[i]);
 	if (positiveItems.length === 0) return false;
 	if (negativeItems.length === 0) return true;
 	return compileBooleanMatcherFromLists(positiveItems, negativeItems);
@@ -43,17 +43,17 @@ const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
 	if (positiveItems.length === 0) return () => "false";
 	if (negativeItems.length === 0) return () => "true";
 	if (positiveItems.length === 1) {
-		return value => `${toSimpleString(positiveItems[0])} == ${value}`;
+		return (value) => `${toSimpleString(positiveItems[0])} == ${value}`;
 	}
 	if (negativeItems.length === 1) {
-		return value => `${toSimpleString(negativeItems[0])} != ${value}`;
+		return (value) => `${toSimpleString(negativeItems[0])} != ${value}`;
 	}
 	const positiveRegexp = itemsToRegexp(positiveItems);
 	const negativeRegexp = itemsToRegexp(negativeItems);
 	if (positiveRegexp.length <= negativeRegexp.length) {
-		return value => `/^${positiveRegexp}$/.test(${value})`;
+		return (value) => `/^${positiveRegexp}$/.test(${value})`;
 	}
-	return value => `!/^${negativeRegexp}$/.test(${value})`;
+	return (value) => `!/^${negativeRegexp}$/.test(${value})`;
 };
 
 /**
@@ -94,7 +94,7 @@ const popCommonItems = (itemsSet, getKey, condition) => {
  * @param {Array<string>} items items
  * @returns {string} common prefix
  */
-const getCommonPrefix = items => {
+const getCommonPrefix = (items) => {
 	let prefix = items[0];
 	for (let i = 1; i < items.length; i++) {
 		const item = items[i];
@@ -112,7 +112,7 @@ const getCommonPrefix = items => {
  * @param {Array<string>} items items
  * @returns {string} common suffix
  */
-const getCommonSuffix = items => {
+const getCommonSuffix = (items) => {
 	let suffix = items[0];
 	for (let i = 1; i < items.length; i++) {
 		const item = items[i];
@@ -130,7 +130,7 @@ const getCommonSuffix = items => {
  * @param {Array<string>} itemsArr array of items
  * @returns {string} regexp
  */
-const itemsToRegexp = itemsArr => {
+const itemsToRegexp = (itemsArr) => {
 	if (itemsArr.length === 1) {
 		return quoteMeta(itemsArr[0]);
 	}
@@ -165,11 +165,11 @@ const itemsToRegexp = itemsArr => {
 	if (finishedItems.length === 0 && items.size === 2) {
 		const prefix = getCommonPrefix(itemsArr);
 		const suffix = getCommonSuffix(
-			itemsArr.map(item => item.slice(prefix.length))
+			itemsArr.map((item) => item.slice(prefix.length))
 		);
 		if (prefix.length > 0 || suffix.length > 0) {
 			return `${quoteMeta(prefix)}${itemsToRegexp(
-				itemsArr.map(i => i.slice(prefix.length, -suffix.length || undefined))
+				itemsArr.map((i) => i.slice(prefix.length, -suffix.length || undefined))
 			)}${quoteMeta(suffix)}`;
 		}
 	}
@@ -190,8 +190,8 @@ const itemsToRegexp = itemsArr => {
 	// find common prefix: (a1|a2|a3|a4|b5) => (a(1|2|3|4)|b5)
 	const prefixed = popCommonItems(
 		items,
-		item => (item.length >= 1 ? item[0] : false),
-		list => {
+		(item) => (item.length >= 1 ? item[0] : false),
+		(list) => {
 			if (list.length >= 3) return true;
 			if (list.length <= 1) return false;
 			return list[0][1] === list[1][1];
@@ -201,7 +201,7 @@ const itemsToRegexp = itemsArr => {
 		const prefix = getCommonPrefix(prefixedItems);
 		finishedItems.push(
 			`${quoteMeta(prefix)}${itemsToRegexp(
-				prefixedItems.map(i => i.slice(prefix.length))
+				prefixedItems.map((i) => i.slice(prefix.length))
 			)}`
 		);
 	}
@@ -209,8 +209,8 @@ const itemsToRegexp = itemsArr => {
 	// find common suffix: (a1|b1|c1|d1|e2) => ((a|b|c|d)1|e2)
 	const suffixed = popCommonItems(
 		items,
-		item => (item.length >= 1 ? item.slice(-1) : false),
-		list => {
+		(item) => (item.length >= 1 ? item.slice(-1) : false),
+		(list) => {
 			if (list.length >= 3) return true;
 			if (list.length <= 1) return false;
 			return list[0].slice(-2) === list[1].slice(-2);
@@ -220,7 +220,7 @@ const itemsToRegexp = itemsArr => {
 		const suffix = getCommonSuffix(suffixedItems);
 		finishedItems.push(
 			`${itemsToRegexp(
-				suffixedItems.map(i => i.slice(0, -suffix.length))
+				suffixedItems.map((i) => i.slice(0, -suffix.length))
 			)}${quoteMeta(suffix)}`
 		);
 	}

package/lib/util/concatenate.js

@@ -22,13 +22,13 @@ const NAMESPACE_OBJECT_EXPORT = "__WEBPACK_NAMESPACE_OBJECT__";
  * @param {Variable} variable variable
  * @returns {Reference[]} references
  */
-const getAllReferences = variable => {
+const getAllReferences = (variable) => {
 	let set = variable.references;
 	// Look for inner scope variables too (like in class Foo { t() { Foo } })
 	const identifiers = new Set(variable.identifiers);
 	for (const scope of variable.scope.childScopes) {
 		for (const innerVar of scope.variables) {
-			if (innerVar.identifiers.some(id => identifiers.has(id))) {
+			if (innerVar.identifiers.some((id) => identifiers.has(id))) {
 				set = [...set, ...innerVar.references];
 				break;
 			}
@@ -53,7 +53,7 @@ const getPathInAst = (ast, node) => {
 	 * @param {Node} n node
 	 * @returns {Node[] | undefined} result
 	 */
-	const enterNode = n => {
+	const enterNode = (n) => {
 		if (!n) return;
 		const r = n.range;
 		if (r && r[0] <= nr[0] && r[1] >= nr[1]) {

package/lib/util/conventions.js

@@ -11,7 +11,7 @@
  * @param {string} string string
  * @returns {string} result
  */
-const preserveCamelCase = string => {
+const preserveCamelCase = (string) => {
 	let result = string;
 	let isLastCharLower = false;
 	let isLastCharUpper = false;
@@ -54,7 +54,7 @@ const preserveCamelCase = string => {
  * @param {string} input input
  * @returns {string} result
  */
-module.exports.camelCase = input => {
+module.exports.camelCase = (input) => {
 	let result = input.trim();
 
 	if (result.length === 0) {
@@ -75,7 +75,7 @@ module.exports.camelCase = input => {
 		.replace(/^[_.\- ]+/, "")
 		.toLowerCase()
 		.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toUpperCase())
-		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toUpperCase());
+		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, (m) => m.toUpperCase());
 };
 
 /**
@@ -121,5 +121,5 @@ module.exports.cssExportConvention = (input, convention) => {
  * @param {string} input input
  * @returns {string} result
  */
-module.exports.dashesCamelCase = input =>
+module.exports.dashesCamelCase = (input) =>
 	input.replace(/-+(\w)/g, (match, firstLetter) => firstLetter.toUpperCase());

package/lib/util/create-schema-validation.js

@@ -22,7 +22,7 @@ const getValidate = memoize(() => require("schema-utils").validate);
  */
 const createSchemaValidation = (check, getSchema, options) => {
 	getSchema = memoize(getSchema);
-	return value => {
+	return (value) => {
 		if (check && value && !check(value)) {
 			getValidate()(
 				getSchema(),

package/lib/util/createHash.js

@@ -154,7 +154,7 @@ let BatchedHash;
  * @param {HashFunction} algorithm the algorithm name or a constructor creating a hash
  * @returns {Hash} the hash
  */
-module.exports = algorithm => {
+module.exports = (algorithm) => {
 	if (typeof algorithm === "function") {
 		// eslint-disable-next-line new-cap
 		return new BulkUpdateDecorator(() => new algorithm());

package/lib/util/deprecation.js

@@ -146,7 +146,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 	 * @param {number} index index
 	 * @returns {() => T | undefined} value
 	 */
-	const createIndexGetter = index => {
+	const createIndexGetter = (index) => {
 		/**
 		 * @this {Set<T>} a Set
 		 * @returns {T | undefined} the value at this location
@@ -164,7 +164,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
 	/**
 	 * @param {number} index index
 	 */
-	const defineIndexGetter = index => {
+	const defineIndexGetter = (index) => {
 		Object.defineProperty(set, index, {
 			get: createIndexGetter(index),
 			set(value) {
@@ -199,7 +199,7 @@ module.exports.arrayToSetDeprecation = (set, name) => {
  * @param {string} name name
  * @returns {{ new <T = any>(values?: readonly T[] | null): SetDeprecatedArray<T> }} SetDeprecatedArray
  */
-module.exports.createArrayToSetDeprecationSet = name => {
+module.exports.createArrayToSetDeprecationSet = (name) => {
 	let initialized = false;
 
 	/**
@@ -275,7 +275,7 @@ const deprecateAllProperties = (obj, message, code) => {
 							 * @param {T} v value
 							 * @returns {T} result
 							 */
-							v => (value = v),
+							(v) => (value = v),
 							message,
 							code
 						)