webpack 5.59.0 → 5.76.0

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -1658,84 +1658,121 @@ const collapse = children => {
 	return newChildren;
 };
 
-const spaceLimited = (itemsAndGroups, max) => {
+const spaceLimited = (
+	itemsAndGroups,
+	max,
+	filteredChildrenLineReserved = false
+) => {
+	if (max < 1) {
+		return {
+			children: undefined,
+			filteredChildren: getTotalItems(itemsAndGroups)
+		};
+	}
 	/** @type {any[] | undefined} */
 	let children = undefined;
 	/** @type {number | undefined} */
 	let filteredChildren = undefined;
 	// This are the groups, which take 1+ lines each
-	const groups = itemsAndGroups.filter(c => c.children || c.filteredChildren);
+	const groups = [];
 	// The sizes of the groups are stored in groupSizes
-	const groupSizes = groups.map(g => getItemSize(g));
+	const groupSizes = [];
 	// This are the items, which take 1 line each
-	const items = itemsAndGroups.filter(c => !c.children && !c.filteredChildren);
+	const items = [];
 	// The total of group sizes
-	let groupsSize = groupSizes.reduce((a, b) => a + b, 0);
+	let groupsSize = 0;
+
+	for (const itemOrGroup of itemsAndGroups) {
+		// is item
+		if (!itemOrGroup.children && !itemOrGroup.filteredChildren) {
+			items.push(itemOrGroup);
+		} else {
+			groups.push(itemOrGroup);
+			const size = getItemSize(itemOrGroup);
+			groupSizes.push(size);
+			groupsSize += size;
+		}
+	}
+
 	if (groupsSize + items.length <= max) {
 		// The total size in the current state fits into the max
 		// keep all
-		children = groups.concat(items);
-	} else if (
-		groups.length > 0 &&
-		groups.length + Math.min(1, items.length) < max
-	) {
-		// If each group would take 1 line the total would be below the maximum
-		// collapse some groups, keep items
-		while (groupsSize + items.length + (filteredChildren ? 1 : 0) > max) {
+		children = groups.length > 0 ? groups.concat(items) : items;
+	} else if (groups.length === 0) {
+		// slice items to max
+		// inner space marks that lines for filteredChildren already reserved
+		const limit = max - (filteredChildrenLineReserved ? 0 : 1);
+		filteredChildren = items.length - limit;
+		items.length = limit;
+		children = items;
+	} else {
+		// limit is the size when all groups are collapsed
+		const limit =
+			groups.length +
+			(filteredChildrenLineReserved || items.length === 0 ? 0 : 1);
+		if (limit < max) {
 			// calculate how much we are over the size limit
 			// this allows to approach the limit faster
-			// it's always > 1
-			const oversize =
-				items.length + groupsSize + (filteredChildren ? 1 : 0) - max;
-			// Find the maximum group and process only this one
-			const maxGroupSize = Math.max(...groupSizes);
-			if (maxGroupSize < items.length) {
-				filteredChildren = items.length;
-				items.length = 0;
-				continue;
-			}
-			for (let i = 0; i < groups.length; i++) {
-				if (groupSizes[i] === maxGroupSize) {
-					const group = groups[i];
-					// run this algorithm recursively and limit the size of the children to
-					// current size - oversize / number of groups
-					// So it should always end up being smaller
-					const headerSize = !group.children
-						? 0
-						: group.filteredChildren
-						? 2
-						: 1;
-					const limited = spaceLimited(
-						group.children,
-						groupSizes[i] - headerSize - oversize / groups.length
-					);
-					groups[i] = {
-						...group,
-						children: limited.children,
-						filteredChildren:
-							(group.filteredChildren || 0) + limited.filteredChildren
-					};
-					const newSize = getItemSize(groups[i]);
-					groupsSize -= groupSizes[i] - newSize;
-					groupSizes[i] = newSize;
-					break;
+			let oversize;
+			// If each group would take 1 line the total would be below the maximum
+			// collapse some groups, keep items
+			while (
+				(oversize =
+					groupsSize +
+					items.length +
+					(filteredChildren && !filteredChildrenLineReserved ? 1 : 0) -
+					max) > 0
+			) {
+				// Find the maximum group and process only this one
+				const maxGroupSize = Math.max(...groupSizes);
+				if (maxGroupSize < items.length) {
+					filteredChildren = items.length;
+					items.length = 0;
+					continue;
+				}
+				for (let i = 0; i < groups.length; i++) {
+					if (groupSizes[i] === maxGroupSize) {
+						const group = groups[i];
+						// run this algorithm recursively and limit the size of the children to
+						// current size - oversize / number of groups
+						// So it should always end up being smaller
+						const headerSize = group.filteredChildren ? 2 : 1;
+						const limited = spaceLimited(
+							group.children,
+							maxGroupSize -
+								// we should use ceil to always feet in max
+								Math.ceil(oversize / groups.length) -
+								// we substitute size of group head
+								headerSize,
+							headerSize === 2
+						);
+						groups[i] = {
+							...group,
+							children: limited.children,
+							filteredChildren: limited.filteredChildren
+								? (group.filteredChildren || 0) + limited.filteredChildren
+								: group.filteredChildren
+						};
+						const newSize = getItemSize(groups[i]);
+						groupsSize -= maxGroupSize - newSize;
+						groupSizes[i] = newSize;
+						break;
+					}
 				}
 			}
+			children = groups.concat(items);
+		} else if (limit === max) {
+			// If we have only enough space to show one line per group and one line for the filtered items
+			// collapse all groups and items
+			children = collapse(groups);
+			filteredChildren = items.length;
+		} else {
+			// If we have no space
+			// collapse complete group
+			filteredChildren = getTotalItems(itemsAndGroups);
 		}
-		children = groups.concat(items);
-	} else if (
-		groups.length > 0 &&
-		groups.length + Math.min(1, items.length) <= max
-	) {
-		// If we have only enough space to show one line per group and one line for the filtered items
-		// collapse all groups and items
-		children = groups.length ? collapse(groups) : undefined;
-		filteredChildren = items.length;
-	} else {
-		// If we have no space
-		// collapse complete group
-		filteredChildren = getTotalItems(itemsAndGroups);
 	}
+
 	return {
 		children,
 		filteredChildren
@@ -1777,6 +1814,9 @@ const reasonGroup = (children, reasons) => {
 	};
 };
 
+const GROUP_EXTENSION_REGEXP = /(\.[^.]+?)(?:\?|(?: \+ \d+ modules?)?$)/;
+const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
+
 /** @type {Record<string, (groupConfigs: GroupConfig[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void>} */
 const ASSETS_GROUPERS = {
 	_: (groupConfigs, context, options) => {
@@ -1825,10 +1865,10 @@ const ASSETS_GROUPERS = {
 			groupConfigs.push({
 				getKeys: asset => {
 					const extensionMatch =
-						groupAssetsByExtension && /(\.[^.]+)(?:\?.*|$)/.exec(asset.name);
+						groupAssetsByExtension && GROUP_EXTENSION_REGEXP.exec(asset.name);
 					const extension = extensionMatch ? extensionMatch[1] : "";
 					const pathMatch =
-						groupAssetsByPath && /(.+)[/\\][^/\\]+(?:\?.*|$)/.exec(asset.name);
+						groupAssetsByPath && GROUP_PATH_REGEXP.exec(asset.name);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
 					const keys = [];
 					if (groupAssetsByPath) {
@@ -2022,11 +2062,13 @@ const MODULES_GROUPERS = type => ({
 				getKeys: module => {
 					if (!module.name) return;
 					const resource = parseResource(module.name.split("!").pop()).path;
+					const dataUrl = /^data:[^,;]+/.exec(resource);
+					if (dataUrl) return [dataUrl[0]];
 					const extensionMatch =
-						groupModulesByExtension && /(\.[^.]+)(?:\?.*|$)/.exec(resource);
+						groupModulesByExtension && GROUP_EXTENSION_REGEXP.exec(resource);
 					const extension = extensionMatch ? extensionMatch[1] : "";
 					const pathMatch =
-						groupModulesByPath && /(.+)[/\\][^/\\]+(?:\?.*|$)/.exec(resource);
+						groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
 					const keys = [];
 					if (groupModulesByPath) {
@@ -2046,11 +2088,14 @@ const MODULES_GROUPERS = type => ({
 					return keys;
 				},
 				createGroup: (key, children, modules) => {
+					const isDataUrl = key.startsWith("data:");
 					return {
-						type: groupModulesByPath
+						type: isDataUrl
+							? "modules by mime type"
+							: groupModulesByPath
 							? "modules by path"
 							: "modules by extension",
-						name: key,
+						name: isDataUrl ? key.slice(/* 'data:'.length */ 5) : key,
 						children,
 						...moduleGroup(children, modules)
 					};
@@ -2110,7 +2155,7 @@ const RESULT_GROUPERS = {
 // remove a prefixed "!" that can be specified to reverse sort order
 const normalizeFieldKey = field => {
 	if (field[0] === "!") {
-		return field.substr(1);
+		return field.slice(1);
 	}
 	return field;
 };

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -9,6 +9,8 @@
 /** @typedef {import("./StatsPrinter")} StatsPrinter */
 /** @typedef {import("./StatsPrinter").StatsPrinterContext} StatsPrinterContext */
 
+const DATA_URI_CONTENT_LENGTH = 16;
+
 const plural = (n, singular, plural) => (n === 1 ? singular : plural);
 
 /**
@@ -26,6 +28,23 @@ const printSizes = (sizes, { formatSize = n => `${n}` }) => {
 	}
 };
 
+const getResourceName = resource => {
+	const dataUrl = /^data:[^,]+,/.exec(resource);
+	if (!dataUrl) return resource;
+
+	const len = dataUrl[0].length + DATA_URI_CONTENT_LENGTH;
+	if (resource.length < len) return resource;
+	return `${resource.slice(
+		0,
+		Math.min(resource.length - /* '..'.length */ 2, len)
+	)}..`;
+};
+
+const getModuleName = name => {
+	const [, prefix, resource] = /^(.*!)?([^!]*)$/.exec(name);
+	return [prefix, getResourceName(resource)];
+};
+
 const mapLines = (str, fn) => str.split("\n").map(fn).join("\n");
 
 /**
@@ -38,6 +57,10 @@ const isValidId = id => {
 	return typeof id === "number" || id;
 };
 
+const moreCount = (list, count) => {
+	return list && list.length > 0 ? `+ ${count}` : `${count}`;
+};
+
 /** @type {Record<string, (thing: any, context: StatsPrinterContext, printer: StatsPrinter) => string | void>} */
 const SIMPLE_PRINTERS = {
 	"compilation.summary!": (
@@ -163,13 +186,24 @@ const SIMPLE_PRINTERS = {
 	},
 	"compilation.assetsByChunkName": () => "",
 
-	"compilation.filteredModules": filteredModules =>
+	"compilation.filteredModules": (
+		filteredModules,
+		{ compilation: { modules } }
+	) =>
 		filteredModules > 0
-			? `${filteredModules} ${plural(filteredModules, "module", "modules")}`
+			? `${moreCount(modules, filteredModules)} ${plural(
+					filteredModules,
+					"module",
+					"modules"
+			  )}`
 			: undefined,
 	"compilation.filteredAssets": (filteredAssets, { compilation: { assets } }) =>
 		filteredAssets > 0
-			? `${filteredAssets} ${plural(filteredAssets, "asset", "assets")}`
+			? `${moreCount(assets, filteredAssets)} ${plural(
+					filteredAssets,
+					"asset",
+					"assets"
+			  )}`
 			: undefined,
 	"compilation.logging": (logging, context, printer) =>
 		Array.isArray(logging)
@@ -262,15 +296,19 @@ const SIMPLE_PRINTERS = {
 	"asset.separator!": () => "\n",
 	"asset.filteredRelated": (filteredRelated, { asset: { related } }) =>
 		filteredRelated > 0
-			? `${filteredRelated} related ${plural(
+			? `${moreCount(related, filteredRelated)} related ${plural(
 					filteredRelated,
 					"asset",
 					"assets"
 			  )}`
 			: undefined,
-	"asset.filteredChildren": filteredChildren =>
+	"asset.filteredChildren": (filteredChildren, { asset: { children } }) =>
 		filteredChildren > 0
-			? `${filteredChildren} ${plural(filteredChildren, "asset", "assets")}`
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"asset",
+					"assets"
+			  )}`
 			: undefined,
 
 	assetChunk: (id, { formatChunkId }) => formatChunkId(id),
@@ -282,8 +320,8 @@ const SIMPLE_PRINTERS = {
 	"module.id": (id, { formatModuleId }) =>
 		isValidId(id) ? formatModuleId(id) : undefined,
 	"module.name": (name, { bold }) => {
-		const [, prefix, resource] = /^(.*!)?([^!]*)$/.exec(name);
-		return (prefix || "") + bold(resource);
+		const [prefix, resource] = getModuleName(name);
+		return `${prefix || ""}${bold(resource || "")}`;
 	},
 	"module.identifier": identifier => undefined,
 	"module.layer": (layer, { formatLayer }) =>
@@ -366,21 +404,29 @@ const SIMPLE_PRINTERS = {
 	"module.issuerPath": (issuerPath, { module }) =>
 		module.profile ? undefined : "",
 	"module.profile": profile => undefined,
-	"module.filteredModules": filteredModules =>
+	"module.filteredModules": (filteredModules, { module: { modules } }) =>
 		filteredModules > 0
-			? `${filteredModules} nested ${plural(
+			? `${moreCount(modules, filteredModules)} nested ${plural(
 					filteredModules,
 					"module",
 					"modules"
 			  )}`
 			: undefined,
-	"module.filteredReasons": filteredReasons =>
+	"module.filteredReasons": (filteredReasons, { module: { reasons } }) =>
 		filteredReasons > 0
-			? `${filteredReasons} ${plural(filteredReasons, "reason", "reasons")}`
+			? `${moreCount(reasons, filteredReasons)} ${plural(
+					filteredReasons,
+					"reason",
+					"reasons"
+			  )}`
 			: undefined,
-	"module.filteredChildren": filteredChildren =>
+	"module.filteredChildren": (filteredChildren, { module: { children } }) =>
 		filteredChildren > 0
-			? `${filteredChildren} ${plural(filteredChildren, "module", "modules")}`
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"module",
+					"modules"
+			  )}`
 			: undefined,
 	"module.separator!": () => "\n",
 
@@ -388,7 +434,8 @@ const SIMPLE_PRINTERS = {
 	"moduleIssuer.profile.total": (value, { formatTime }) => formatTime(value),
 
 	"moduleReason.type": type => type,
-	"moduleReason.userRequest": (userRequest, { cyan }) => cyan(userRequest),
+	"moduleReason.userRequest": (userRequest, { cyan }) =>
+		cyan(getResourceName(userRequest)),
 	"moduleReason.moduleId": (moduleId, { formatModuleId }) =>
 		isValidId(moduleId) ? formatModuleId(moduleId) : undefined,
 	"moduleReason.module": (module, { magenta }) => magenta(module),
@@ -397,9 +444,16 @@ const SIMPLE_PRINTERS = {
 	"moduleReason.active": (active, { formatFlag }) =>
 		active ? undefined : formatFlag("inactive"),
 	"moduleReason.resolvedModule": (module, { magenta }) => magenta(module),
-	"moduleReason.filteredChildren": filteredChildren =>
+	"moduleReason.filteredChildren": (
+		filteredChildren,
+		{ moduleReason: { children } }
+	) =>
 		filteredChildren > 0
-			? `${filteredChildren} ${plural(filteredChildren, "reason", "reasons")}`
+			? `${moreCount(children, filteredChildren)} ${plural(
+					filteredChildren,
+					"reason",
+					"reasons"
+			  )}`
 			: undefined,
 
 	"module.profile.total": (value, { formatTime }) => formatTime(value),
@@ -427,10 +481,21 @@ const SIMPLE_PRINTERS = {
 		size ? formatSize(size) : undefined,
 	"chunkGroup.auxiliaryAssetsSize": (size, { formatSize }) =>
 		size ? `(${formatSize(size)})` : undefined,
-	"chunkGroup.filteredAssets": n =>
-		n > 0 ? `${n} ${plural(n, "asset", "assets")}` : undefined,
-	"chunkGroup.filteredAuxiliaryAssets": n =>
-		n > 0 ? `${n} auxiliary ${plural(n, "asset", "assets")}` : undefined,
+	"chunkGroup.filteredAssets": (n, { chunkGroup: { assets } }) =>
+		n > 0
+			? `${moreCount(assets, n)} ${plural(n, "asset", "assets")}`
+			: undefined,
+	"chunkGroup.filteredAuxiliaryAssets": (
+		n,
+		{ chunkGroup: { auxiliaryAssets } }
+	) =>
+		n > 0
+			? `${moreCount(auxiliaryAssets, n)} auxiliary ${plural(
+					n,
+					"asset",
+					"assets"
+			  )}`
+			: undefined,
 	"chunkGroup.is!": () => "=",
 	"chunkGroupAsset.name": (asset, { green }) => green(asset),
 	"chunkGroupAsset.size": (size, { formatSize, chunkGroup }) =>
@@ -490,9 +555,9 @@ const SIMPLE_PRINTERS = {
 	"chunk.recorded": (recorded, { formatFlag, green }) =>
 		recorded ? green(formatFlag("recorded")) : undefined,
 	"chunk.reason": (reason, { yellow }) => (reason ? yellow(reason) : undefined),
-	"chunk.filteredModules": filteredModules =>
+	"chunk.filteredModules": (filteredModules, { chunk: { modules } }) =>
 		filteredModules > 0
-			? `${filteredModules} chunk ${plural(
+			? `${moreCount(modules, filteredModules)} chunk ${plural(
 					filteredModules,
 					"module",
 					"modules"
@@ -1088,7 +1153,7 @@ const SIMPLE_ELEMENT_JOINERS = {
 	chunkOrigin: items => "> " + joinOneLine(items),
 	"errors[].error": joinError(true),
 	"warnings[].error": joinError(false),
-	loggingGroup: items => joinExplicitNewLine(items, "").trimRight(),
+	loggingGroup: items => joinExplicitNewLine(items, "").trimEnd(),
 	moduleTraceItem: items => " @ " + joinOneLine(items),
 	moduleTraceDependency: joinOneLine
 };
@@ -1160,7 +1225,7 @@ const AVAILABLE_FORMATS = {
 			},
 			{ regExp: /(\(module has no exports\))/g, format: red },
 			{ regExp: /\(possible exports: (.+)\)/g, format: green },
-			{ regExp: /\s*(.+ doesn't exist)/g, format: red },
+			{ regExp: /(?:^|\n)(.* doesn't exist)/g, format: red },
 			{ regExp: /('\w+' option has not been set)/g, format: red },
 			{
 				regExp: /(Emitted value instead of an instance of Error)/g,

package/lib/util/ArrayHelpers.js

@@ -5,6 +5,14 @@
 
 "use strict";
 
+/**
+ * Compare two arrays or strings by performing strict equality check for each value.
+ * @template T [T=any]
+ * @param {ArrayLike<T>} a Array of values to be compared
+ * @param {ArrayLike<T>} b Array of values to be compared
+ * @returns {boolean} returns true if all the elements of passed arrays are strictly equal.
+ */
+
 exports.equals = (a, b) => {
 	if (a.length !== b.length) return false;
 	for (let i = 0; i < a.length; i++) {
@@ -12,3 +20,25 @@ exports.equals = (a, b) => {
 	}
 	return true;
 };
+
+/**
+ * Partition an array by calling a predicate function on each value.
+ * @template T [T=any]
+ * @param {Array<T>} arr Array of values to be partitioned
+ * @param {(value: T) => boolean} fn Partition function which partitions based on truthiness of result.
+ * @returns {[Array<T>, Array<T>]} returns the values of `arr` partitioned into two new arrays based on fn predicate.
+ */
+exports.groupBy = (arr = [], fn) => {
+	return arr.reduce(
+		/**
+		 * @param {[Array<T>, Array<T>]} groups An accumulator storing already partitioned values returned from previous call.
+		 * @param {T} value The value of the current element
+		 * @returns {[Array<T>, Array<T>]} returns an array of partitioned groups accumulator resulting from calling a predicate on the current value.
+		 */
+		(groups, value) => {
+			groups[fn(value) ? 0 : 1].push(value);
+			return groups;
+		},
+		[[], []]
+	);
+};

package/lib/util/AsyncQueue.js

@@ -19,7 +19,7 @@ let inHandleResult = 0;
 /**
  * @template T
  * @callback Callback
- * @param {WebpackError=} err
+ * @param {(WebpackError | null)=} err
  * @param {T=} result
  */
 

package/lib/util/compileBooleanMatcher.js

@@ -18,7 +18,7 @@ const toSimpleString = str => {
 
 /**
  * @param {Record<string|number, boolean>} map value map
- * @returns {true|false|function(string): string} true/false, when unconditionally true/false, or a template function to determine the value at runtime
+ * @returns {boolean|(function(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]);

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

@@ -9,11 +9,18 @@ const memoize = require("./memoize");
 
 const getValidate = memoize(() => require("schema-utils").validate);
 
-const createSchemaValidation = (check = v => false, getSchema, options) => {
+const createSchemaValidation = (check, getSchema, options) => {
 	getSchema = memoize(getSchema);
 	return value => {
-		if (!check(value)) {
+		if (check && !check(value)) {
 			getValidate()(getSchema(), value, options);
+			if (check) {
+				require("util").deprecate(
+					() => {},
+					"webpack bug: Pre-compiled schema reports error while real schema is happy. This has performance drawbacks.",
+					"DEP_WEBPACK_PRE_COMPILED_SCHEMA_INVALID"
+				)();
+			}
 		}
 	};
 };

package/lib/util/createHash.js

@@ -126,6 +126,7 @@ class DebugHash extends Hash {
 
 let crypto = undefined;
 let createXXHash64 = undefined;
+let createMd4 = undefined;
 let BatchedHash = undefined;
 
 /**
@@ -149,6 +150,17 @@ module.exports = algorithm => {
 				}
 			}
 			return new BatchedHash(createXXHash64());
+		case "md4":
+			if (createMd4 === undefined) {
+				createMd4 = require("./hash/md4");
+				if (BatchedHash === undefined) {
+					BatchedHash = require("./hash/BatchedHash");
+				}
+			}
+			return new BatchedHash(createMd4());
+		case "native-md4":
+			if (crypto === undefined) crypto = require("crypto");
+			return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
 		default:
 			if (crypto === undefined) crypto = require("crypto");
 			return new BulkUpdateDecorator(

package/lib/util/deprecation.js

@@ -165,8 +165,16 @@ exports.arrayToSetDeprecation = (set, name) => {
 };
 
 exports.createArrayToSetDeprecationSet = name => {
-	class SetDeprecatedArray extends Set {}
-	exports.arrayToSetDeprecation(SetDeprecatedArray.prototype, name);
+	let initialized = false;
+	class SetDeprecatedArray extends Set {
+		constructor(items) {
+			super(items);
+			if (!initialized) {
+				initialized = true;
+				exports.arrayToSetDeprecation(SetDeprecatedArray.prototype, name);
+			}
+		}
+	}
 	return SetDeprecatedArray;
 };
 

package/lib/util/deterministicGrouping.js

@@ -498,7 +498,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 	// return the results
 	return result.map(group => {
-		/** @type {GroupedItems} */
+		/** @type {GroupedItems<T>} */
 		return {
 			key: group.key,
 			items: group.nodes.map(node => node.item),

package/lib/util/extractUrlAndGlobal.js

@@ -11,5 +11,8 @@
  */
 module.exports = function extractUrlAndGlobal(urlAndGlobal) {
 	const index = urlAndGlobal.indexOf("@");
+	if (index <= 0 || index === urlAndGlobal.length - 1) {
+		throw new Error(`Invalid request "${urlAndGlobal}"`);
+	}
 	return [urlAndGlobal.substring(index + 1), urlAndGlobal.substring(0, index)];
 };

package/lib/util/fs.js

@@ -61,6 +61,15 @@ const path = require("path");
 /** @typedef {function((NodeJS.ErrnoException | Error | null)=, any=): void} ReadJsonCallback */
 /** @typedef {function((NodeJS.ErrnoException | Error | null)=, IStats|string=): void} LstatReadlinkAbsoluteCallback */
 
+/**
+ * @typedef {Object} WatcherInfo
+ * @property {Set<string>} changes get current aggregated changes that have not yet send to callback
+ * @property {Set<string>} removals get current aggregated removals that have not yet send to callback
+ * @property {Map<string, FileSystemInfoEntry | "ignore">} fileTimeInfoEntries get info about files
+ * @property {Map<string, FileSystemInfoEntry | "ignore">} contextTimeInfoEntries get info about directories
+ */
+
+// TODO webpack 6 deprecate missing getInfo
 /**
  * @typedef {Object} Watcher
  * @property {function(): void} close closes the watcher and all underlying file watchers
@@ -69,6 +78,7 @@ const path = require("path");
  * @property {function(): Set<string>=} getAggregatedRemovals get current aggregated removals that have not yet send to callback
  * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getFileTimeInfoEntries get info about files
  * @property {function(): Map<string, FileSystemInfoEntry | "ignore">} getContextTimeInfoEntries get info about directories
+ * @property {function(): WatcherInfo=} getInfo get info about timestamps and changes
  */
 
 /**
@@ -93,6 +103,7 @@ const path = require("path");
  * @property {function(string, Callback): void=} rmdir
  * @property {function(string, Callback): void=} unlink
  * @property {function(string, StatsCallback): void} stat
+ * @property {function(string, StatsCallback): void=} lstat
  * @property {function(string, BufferOrStringCallback): void} readFile
  * @property {(function(string, string): string)=} join
  * @property {(function(string, string): string)=} relative