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

package/lib/NormalModuleFactory.js

@@ -8,6 +8,7 @@
 const asyncLib = require("neo-async");
 const {
 	AsyncSeriesBailHook,
+	AsyncSeriesHook,
 	HookMap,
 	SyncBailHook,
 	SyncHook,
@@ -23,44 +24,83 @@ const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
 const { getContext } = require("./loaders/LoaderRunner");
 const BasicEffectRulePlugin = require("./rules/BasicEffectRulePlugin");
 const BasicMatcherRulePlugin = require("./rules/BasicMatcherRulePlugin");
+const GlobMatcherRulePlugin = require("./rules/GlobMatcherRulePlugin");
 const ObjectMatcherRulePlugin = require("./rules/ObjectMatcherRulePlugin");
 const RuleSetCompiler = require("./rules/RuleSetCompiler");
 const UseEffectRulePlugin = require("./rules/UseEffectRulePlugin");
 const LazySet = require("./util/LazySet");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");
-const { join } = require("./util/fs");
 const {
+	applyCaseCorrections,
+	findCaseMismatch
+} = require("./util/findCaseMismatch");
+const { dirname, join, relative } = require("./util/fs");
+const {
+	ABSOLUTE_PATH_REGEXP,
+	WINDOWS_PATH_SEPARATOR_REGEXP,
 	escapeHashInPathRequest,
 	parseResource,
 	parseResourceWithoutFragment
 } = require("./util/identifier");
+const matchAlias = require("./util/matchAlias");
 
-/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
-/** @typedef {import("../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptions */
-/** @typedef {import("../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
-/** @typedef {import("./Compilation").FileSystemDependencies} FileSystemDependencies */
-/** @typedef {import("./Generator")} Generator */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ModuleFactory").ModuleFactoryCreateDataContextInfo} ModuleFactoryCreateDataContextInfo */
-/** @typedef {import("./ModuleFactory").ModuleFactoryResult} ModuleFactoryResult */
-/** @typedef {import("./NormalModule").GeneratorOptions} GeneratorOptions */
-/** @typedef {import("./NormalModule").LoaderItem} LoaderItem */
-/** @typedef {import("./NormalModule").NormalModuleCreateData} NormalModuleCreateData */
-/** @typedef {import("./NormalModule").ParserOptions} ParserOptions */
-/** @typedef {import("./Parser")} Parser */
-/** @typedef {import("./ResolverFactory")} ResolverFactory */
-/** @typedef {import("./ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("./dependencies/ModuleDependency")} ModuleDependency */
-/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
-/** @typedef {import("./dependencies/ImportPhase").ImportPhaseName} ImportPhaseName */
-/** @typedef {import("./javascript/JavascriptParser").ImportAttributes} ImportAttributes */
-/** @typedef {import("./rules/RuleSetCompiler").RuleSetRules} RuleSetRules */
-/** @typedef {import("./rules/RuleSetCompiler").RuleSet} RuleSet */
-/** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("./util/identifier").AssociatedObjectForCache} AssociatedObjectForCache */
+/** @typedef {import("enhanced-resolve").Resolver["options"]["alias"]} AliasOptions */
+/** @import { ResolveContext, ResolveRequest } from "enhanced-resolve" */
+/**
+ * @import {
+ * 	ModuleOptionsNormalized as ModuleOptions,
+ * 	RuleSetRule,
+ * 	JavascriptParserOptions,
+ * 	EmptyGeneratorOptions,
+ * 	JsonParserOptions,
+ * 	JsonGeneratorOptions,
+ * 	AssetParserOptions,
+ * 	EmptyParserOptions,
+ * 	AssetGeneratorOptions,
+ * 	CssParserOptions,
+ * 	CssModuleParserOptions,
+ * 	CssGeneratorOptions,
+ * 	CssModuleGeneratorOptions,
+ * 	EmptyParserOptions as HtmlParserOptions,
+ * 	HtmlGeneratorOptions
+ * } from "../declarations/WebpackOptions"
+ */
+/** @import { FileSystemDependencies } from "./Compilation" */
+/** @import Generator from "./Generator" */
+/**
+ * @import {
+ * 	ModuleFactoryCallback,
+ * 	ModuleFactoryCreateData,
+ * 	ModuleFactoryCreateDataContextInfo,
+ * 	ModuleFactoryResult
+ * } from "./ModuleFactory"
+ */
+/**
+ * @import {
+ * 	GeneratorOptions,
+ * 	LoaderItem,
+ * 	NormalModuleCreateData,
+ * 	ParserOptions
+ * } from "./NormalModule"
+ */
+/** @import Parser from "./Parser" */
+/** @import ResolverFactory, { ResolverWithOptions } from "./ResolverFactory" */
+/** @import ModuleDependency from "./dependencies/ModuleDependency" */
+/**
+ * @import {
+ * 	ImportPhaseType,
+ * 	ImportPhaseName
+ * } from "./dependencies/ImportPhase"
+ */
+/**
+ * @import JavascriptParser, {
+ * 	ImportAttributes
+ * } from "./javascript/JavascriptParser"
+ */
+/** @import { RuleSetRules, RuleSet } from "./rules/RuleSetCompiler" */
+/** @import { InputFileSystem } from "./util/fs" */
+/** @import { AssociatedObjectForCache } from "./util/identifier" */
 
 /**
  * Defines the callback type used by this module.
@@ -131,22 +171,25 @@ const {
  * @typedef {ResolveDependencies & { loader: string, query: string | undefined, type: string | undefined }} LoaderResolveCacheEntry
  */
 
-/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_AUTO} JAVASCRIPT_MODULE_TYPE_AUTO */
-/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_DYNAMIC} JAVASCRIPT_MODULE_TYPE_DYNAMIC */
-/** @typedef {import("./ModuleTypeConstants").JAVASCRIPT_MODULE_TYPE_ESM} JAVASCRIPT_MODULE_TYPE_ESM */
-/** @typedef {import("./ModuleTypeConstants").JSON_MODULE_TYPE} JSON_MODULE_TYPE */
-/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE} ASSET_MODULE_TYPE */
-/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_INLINE} ASSET_MODULE_TYPE_INLINE */
-/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_RESOURCE} ASSET_MODULE_TYPE_RESOURCE */
-/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_SOURCE} ASSET_MODULE_TYPE_SOURCE */
-/** @typedef {import("./ModuleTypeConstants").ASSET_MODULE_TYPE_BYTES} ASSET_MODULE_TYPE_BYTES */
-/** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_ASYNC} WEBASSEMBLY_MODULE_TYPE_ASYNC */
-/** @typedef {import("./ModuleTypeConstants").WEBASSEMBLY_MODULE_TYPE_SYNC} WEBASSEMBLY_MODULE_TYPE_SYNC */
-/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE} CSS_MODULE_TYPE */
-/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_GLOBAL} CSS_MODULE_TYPE_GLOBAL */
-/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_MODULE} CSS_MODULE_TYPE_MODULE */
-/** @typedef {import("./ModuleTypeConstants").CSS_MODULE_TYPE_AUTO} CSS_MODULE_TYPE_AUTO */
-/** @typedef {import("./ModuleTypeConstants").HTML_MODULE_TYPE} HTML_MODULE_TYPE */
+/**
+ * @import {
+ * 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
+ * 	JAVASCRIPT_MODULE_TYPE_ESM,
+ * 	JSON_MODULE_TYPE,
+ * 	ASSET_MODULE_TYPE,
+ * 	ASSET_MODULE_TYPE_INLINE,
+ * 	ASSET_MODULE_TYPE_RESOURCE,
+ * 	ASSET_MODULE_TYPE_SOURCE,
+ * 	ASSET_MODULE_TYPE_BYTES,
+ * 	WEBASSEMBLY_MODULE_TYPE_ASYNC,
+ * 	WEBASSEMBLY_MODULE_TYPE_SYNC,
+ * 	CSS_MODULE_TYPE,
+ * 	CSS_MODULE_TYPE_GLOBAL,
+ * 	CSS_MODULE_TYPE_MODULE,
+ * 	CSS_MODULE_TYPE_AUTO,
+ * 	HTML_MODULE_TYPE
+ * } from "./ModuleTypeConstants"
+ */
 
 /** @typedef {JAVASCRIPT_MODULE_TYPE_AUTO | JAVASCRIPT_MODULE_TYPE_DYNAMIC | JAVASCRIPT_MODULE_TYPE_ESM | JSON_MODULE_TYPE | ASSET_MODULE_TYPE | ASSET_MODULE_TYPE_INLINE | ASSET_MODULE_TYPE_RESOURCE | ASSET_MODULE_TYPE_SOURCE | WEBASSEMBLY_MODULE_TYPE_ASYNC | WEBASSEMBLY_MODULE_TYPE_SYNC | CSS_MODULE_TYPE | CSS_MODULE_TYPE_GLOBAL | CSS_MODULE_TYPE_MODULE | CSS_MODULE_TYPE_AUTO | HTML_MODULE_TYPE} KnownNormalModuleTypes */
 /** @typedef {KnownNormalModuleTypes | string} NormalModuleTypes */
@@ -161,6 +204,174 @@ const EMPTY_ELEMENTS = [];
 
 const MATCH_RESOURCE_REGEX = /^([^!]+)!=!/;
 const LEADING_DOT_EXTENSION_REGEX = /^[^.]/;
+// Nothing in `util/identifier` matches a request (as opposed to a path) shape.
+const RELATIVE_REQUEST_REGEXP = /^\.\.?[\\/]/;
+
+/**
+ * Computes the edit distance of two strings, counting swapped neighbors as one
+ * edit and giving up as soon as the distance exceeds `max`.
+ * @param {string} a first string
+ * @param {string} b second string
+ * @param {number} max largest distance worth distinguishing
+ * @returns {number} the distance, or a value greater than `max` when it exceeds `max`
+ */
+const editDistance = (a, b, max) => {
+	if (a === b) return 0;
+	if (Math.abs(a.length - b.length) > max) return max + 1;
+	/** @type {number[] | undefined} */
+	let rowBeforePrevious;
+	/** @type {number[]} */
+	let previousRow = [];
+	for (let column = 0; column <= b.length; column++) previousRow.push(column);
+	for (let row = 1; row <= a.length; row++) {
+		const currentRow = [row];
+		let rowMinimum = row;
+		for (let column = 1; column <= b.length; column++) {
+			let distance = Math.min(
+				previousRow[column - 1] + (a[row - 1] === b[column - 1] ? 0 : 1),
+				previousRow[column] + 1,
+				currentRow[column - 1] + 1
+			);
+			if (
+				rowBeforePrevious &&
+				a[row - 1] === b[column - 2] &&
+				a[row - 2] === b[column - 1]
+			) {
+				distance = Math.min(distance, rowBeforePrevious[column - 2] + 1);
+			}
+			currentRow.push(distance);
+			if (distance < rowMinimum) rowMinimum = distance;
+		}
+		if (rowMinimum > max) return max + 1;
+		rowBeforePrevious = previousRow;
+		previousRow = currentRow;
+	}
+	return previousRow[b.length];
+};
+
+/**
+ * Names an entry of a directory can be requested by: as written, and without
+ * the extension the resolver would have appended.
+ * @param {string} entry name of a directory entry
+ * @param {Set<string>} extensions the resolvable extensions
+ * @returns {string[]} names the entry answers to
+ */
+const namesForEntry = (entry, extensions) => {
+	const names = [entry];
+	for (const extension of extensions) {
+		if (entry.length > extension.length && entry.endsWith(extension)) {
+			names.push(entry.slice(0, -extension.length));
+		}
+	}
+	return names;
+};
+
+/**
+ * Picks the entry of a directory a failed request most likely meant. Ties are
+ * broken by name so the hint does not depend on the order the directory lists.
+ * @param {string} requested the requested file name
+ * @param {string[]} entries names in the directory
+ * @param {Set<string>} extensions the resolvable extensions
+ * @returns {{ entry: string, distance: number } | undefined} the closest entry and how far it is from the request
+ */
+const findClosestEntry = (requested, entries, extensions) => {
+	// A typo is only distinguishable from an unrelated name once the name is
+	// long enough, so short requests are matched by casing alone.
+	let allowedDistance = requested.length < 4 ? 0 : requested.length < 8 ? 1 : 2;
+	const lowerCaseRequested = requested.toLowerCase();
+	/** @type {{ entry: string, distance: number } | undefined} */
+	let best;
+	for (const entry of entries) {
+		// The entry exists as requested, so the request failed for another reason.
+		if (entry === requested) return;
+		for (const name of namesForEntry(entry, extensions)) {
+			const distance = editDistance(
+				lowerCaseRequested,
+				name.toLowerCase(),
+				allowedDistance
+			);
+			if (distance > allowedDistance) continue;
+			if (best && distance === allowedDistance && entry >= best.entry) continue;
+			allowedDistance = distance;
+			best = { entry, distance };
+		}
+	}
+	return best;
+};
+
+/** Bounds the walk up the context when a module request is looked up. */
+const MAX_MODULE_LOOKUP_DIRECTORIES = 10;
+
+/** Bounds the paths a failed request is looked for under, aliases included. */
+const MAX_SUGGESTION_CANDIDATES = 20;
+
+/**
+ * Directories a module request is looked up in, nearest first.
+ * @param {InputFileSystem} fs input file system
+ * @param {string} context directory the request comes from
+ * @param {Iterable<string | string[]>} modules the `resolve.modules` entries
+ * @returns {string[]} absolute directories
+ */
+const moduleLookupDirectories = (fs, context, modules) => {
+	/** @type {string[]} */
+	const relativeNames = [];
+	/** @type {string[]} */
+	const directories = [];
+	for (const entry of modules) {
+		for (const name of Array.isArray(entry) ? entry : [entry]) {
+			if (ABSOLUTE_PATH_REGEXP.test(name)) {
+				directories.push(name);
+			} else {
+				relativeNames.push(name);
+			}
+		}
+	}
+	let current = context;
+	while (
+		relativeNames.length > 0 &&
+		directories.length < MAX_MODULE_LOOKUP_DIRECTORIES
+	) {
+		for (const name of relativeNames) directories.push(join(fs, current, name));
+		const parent = dirname(fs, current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return directories;
+};
+
+/**
+ * Requests an alias could have turned this one into, so a hint can look where
+ * the resolver looked. Mirrors `AliasPlugin`: a name matches the whole request
+ * or a leading segment of it, and `onlyModule` restricts it to the former.
+ * @param {string} request the request as written
+ * @param {AliasOptions} aliases the `resolve.alias` entries
+ * @returns {string[]} the requests the aliases map this one to
+ */
+const aliasedRequests = (request, aliases) => {
+	/** @type {string[]} */
+	const requests = [];
+	for (const { name, alias, onlyModule } of aliases) {
+		if (!matchAlias(request, name, onlyModule)) continue;
+		const tail = request.slice(name.length);
+		for (const target of Array.isArray(alias) ? alias : [alias]) {
+			// `false` tells the resolver to ignore the request, so it names no path
+			if (typeof target === "string") requests.push(target + tail);
+		}
+	}
+	return requests;
+};
+
+/**
+ * Whether a request spells out directories of its own, as opposed to naming an
+ * entry of the directory it is resolved against.
+ * @param {string} prefix the request without its last segment
+ * @returns {boolean} true when the prefix names at least one directory
+ */
+const namesDirectories = (prefix) =>
+	prefix
+		.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/")
+		.split("/")
+		.some((segment) => segment !== "" && segment !== "." && segment !== "..");
 
 /**
  * Replays the file/context/missing dependencies captured by a loader resolve
@@ -282,6 +493,7 @@ const deprecationChangedHookMessage = (name, hook) => {
 
 const ruleSetCompiler = new RuleSetCompiler([
 	new BasicMatcherRulePlugin("test", "resource"),
+	new GlobMatcherRulePlugin("glob", "resource"),
 	new BasicMatcherRulePlugin("scheme"),
 	new BasicMatcherRulePlugin("mimetype"),
 	new BasicMatcherRulePlugin("dependency"),
@@ -311,6 +523,7 @@ const ruleSetCompiler = new RuleSetCompiler([
 		return false;
 	}),
 	new ObjectMatcherRulePlugin("descriptionData"),
+	new BasicMatcherRulePlugin("descriptionRelativePath"),
 	new BasicEffectRulePlugin("type"),
 	new BasicEffectRulePlugin("sideEffects"),
 	new BasicEffectRulePlugin("parser"),
@@ -321,42 +534,26 @@ const ruleSetCompiler = new RuleSetCompiler([
 	new UseEffectRulePlugin()
 ]);
 
-/** @typedef {import("./javascript/JavascriptParser")} JavascriptParser */
-/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
-/** @typedef {import("./javascript/JavascriptGenerator")} JavascriptGenerator */
-/** @typedef {import("../declarations/WebpackOptions").EmptyGeneratorOptions} EmptyGeneratorOptions */
-
-/** @typedef {import("./json/JsonParser")} JsonParser */
-/** @typedef {import("../declarations/WebpackOptions").JsonParserOptions} JsonParserOptions */
-/** @typedef {import("./json/JsonGenerator")} JsonGenerator */
-/** @typedef {import("../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
-
-/** @typedef {import("./asset/AssetParser")} AssetParser */
-/** @typedef {import("./asset/AssetSourceParser")} AssetSourceParser */
-/** @typedef {import("./asset/AssetBytesParser")} AssetBytesParser */
-/** @typedef {import("../declarations/WebpackOptions").AssetParserOptions} AssetParserOptions */
-/** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} EmptyParserOptions */
-/** @typedef {import("./asset/AssetGenerator")} AssetGenerator */
-/** @typedef {import("../declarations/WebpackOptions").AssetGeneratorOptions} AssetGeneratorOptions */
-/** @typedef {import("../declarations/WebpackOptions").AssetInlineGeneratorOptions} AssetInlineGeneratorOptions */
-/** @typedef {import("../declarations/WebpackOptions").AssetResourceGeneratorOptions} AssetResourceGeneratorOptions */
-/** @typedef {import("./asset/AssetSourceGenerator")} AssetSourceGenerator */
-/** @typedef {import("./asset/AssetBytesGenerator")} AssetBytesGenerator */
-
-/** @typedef {import("./wasm-async/AsyncWebAssemblyParser")} AsyncWebAssemblyParser */
-/** @typedef {import("./wasm-sync/WebAssemblyParser")} WebAssemblyParser */
-
-/** @typedef {import("./css/CssParser")} CssParser */
-/** @typedef {import("../declarations/WebpackOptions").CssParserOptions} CssParserOptions */
-/** @typedef {import("../declarations/WebpackOptions").CssModuleParserOptions} CssModuleParserOptions */
-/** @typedef {import("./css/CssGenerator")} CssGenerator */
-/** @typedef {import("../declarations/WebpackOptions").CssGeneratorOptions} CssGeneratorOptions */
-/** @typedef {import("../declarations/WebpackOptions").CssModuleGeneratorOptions} CssModuleGeneratorOptions */
-
-/** @typedef {import("./html/HtmlParser")} HtmlParser */
-/** @typedef {import("../declarations/WebpackOptions").EmptyParserOptions} HtmlParserOptions */
-/** @typedef {import("./html/HtmlGenerator")} HtmlGenerator */
-/** @typedef {import("../declarations/WebpackOptions").HtmlGeneratorOptions} HtmlGeneratorOptions */
+/** @import JavascriptGenerator from "./javascript/JavascriptGenerator" */
+
+/** @import JsonParser from "./json/JsonParser" */
+/** @import JsonGenerator from "./json/JsonGenerator" */
+
+/** @import AssetParser from "./asset/AssetParser" */
+/** @import AssetSourceParser from "./asset/AssetSourceParser" */
+/** @import AssetBytesParser from "./asset/AssetBytesParser" */
+/** @import AssetGenerator from "./asset/AssetGenerator" */
+/** @import AssetSourceGenerator from "./asset/AssetSourceGenerator" */
+/** @import AssetBytesGenerator from "./asset/AssetBytesGenerator" */
+
+/** @import AsyncWebAssemblyParser from "./wasm-async/AsyncWebAssemblyParser" */
+/** @import WebAssemblyParser from "./wasm-sync/WebAssemblyParser" */
+
+/** @import CssParser from "./css/CssParser" */
+/** @import CssGenerator from "./css/CssGenerator" */
+
+/** @import HtmlParser from "./html/HtmlParser" */
+/** @import HtmlGenerator from "./html/HtmlGenerator" */
 
 /* eslint-disable jsdoc/type-formatting */
 /**
@@ -452,6 +649,11 @@ class NormalModuleFactory extends ModuleFactory {
 			createModule: new AsyncSeriesBailHook(["createData", "resolveData"]),
 			/** @type {SyncWaterfallHook<[Module, CreateData, ResolveData]>} */
 			module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
+			/**
+			 * @type {HookMap<AsyncSeriesHook<[]>>}
+			 * @since 5.110.0
+			 */
+			prepareModuleType: new HookMap(() => new AsyncSeriesHook([])),
 			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [2], 1>>} */
 			createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
 			/** @type {import("tapable").TypedHookMap<RecordFactoryFromTuple<ParsersAndGeneratorsByTypes, [1, 2]>>} */
@@ -493,6 +695,10 @@ class NormalModuleFactory extends ModuleFactory {
 		this.parserCache = new Map();
 		/** @type {Map<string, WeakMap<GeneratorOptions, Generator>>} */
 		this.generatorCache = new Map();
+		// `true` once a type is prepared, otherwise the calls waiting on the
+		// in-flight `prepareModuleType` for it
+		/** @type {Map<string, true | Callback<void>[]>} */
+		this._moduleTypePreparation = new Map();
 		/** @type {Set<Module>} */
 		this._restoredUnsafeCacheEntries = new Set();
 		/** @type {Map<string, LoaderResolveCacheEntry>} */
@@ -779,6 +985,9 @@ class NormalModuleFactory extends ModuleFactory {
 							descriptionData: matchResourceData
 								? undefined
 								: resourceData.data.descriptionFileData,
+							descriptionRelativePath: matchResourceData
+								? undefined
+								: resourceData.data.relativePath,
 							issuer: contextInfo.issuer,
 							compiler: contextInfo.compiler,
 							issuerLayer: contextInfo.issuerLayer || ""
@@ -857,37 +1066,46 @@ class NormalModuleFactory extends ModuleFactory {
 						const resolveOptions = settings.resolve;
 						const layer = settings.layer;
 
-						try {
-							Object.assign(data.createData, {
-								layer:
-									layer === undefined ? contextInfo.issuerLayer || null : layer,
-								request: stringifyLoadersAndResource(
-									allLoaders,
-									resourceData.resource
-								),
-								userRequest,
-								rawRequest: request,
-								loaders: allLoaders,
-								resource: resourceData.resource,
-								context:
-									resourceData.context || getContext(resourceData.resource),
-								matchResource: matchResourceData
-									? matchResourceData.resource
-									: undefined,
-								resourceResolveData: resourceData.data,
-								settings,
-								type,
-								parser: this.getParser(type, settings.parser),
-								parserOptions: settings.parser,
-								generator: this.getGenerator(type, settings.generator),
-								generatorOptions: settings.generator,
-								resolveOptions,
-								extractSourceMap: settings.extractSourceMap || false
-							});
-						} catch (createDataErr) {
-							return callback(/** @type {Error} */ (createDataErr));
-						}
-						callback();
+						const applyCreateData = () => {
+							try {
+								Object.assign(data.createData, {
+									layer:
+										layer === undefined
+											? contextInfo.issuerLayer || null
+											: layer,
+									request: stringifyLoadersAndResource(
+										allLoaders,
+										resourceData.resource
+									),
+									userRequest,
+									rawRequest: request,
+									loaders: allLoaders,
+									resource: resourceData.resource,
+									context:
+										resourceData.context || getContext(resourceData.resource),
+									matchResource: matchResourceData
+										? matchResourceData.resource
+										: undefined,
+									resourceResolveData: resourceData.data,
+									settings,
+									type,
+									parser: this.getParser(type, settings.parser),
+									parserOptions: settings.parser,
+									generator: this.getGenerator(type, settings.generator),
+									generatorOptions: settings.generator,
+									resolveOptions,
+									extractSourceMap: settings.extractSourceMap || false
+								});
+							} catch (createDataErr) {
+								return callback(/** @type {Error} */ (createDataErr));
+							}
+							callback();
+						};
+
+						this._prepareModuleType(type, (err) => {
+							if (err) return callback(err);
+							applyCreateData();
+						});
 					});
 					this.resolveRequestArray(
 						contextInfo,
@@ -1244,6 +1462,183 @@ ${hints.join("\n\n")}`;
 		resolveContext,
 		callback
 	) {
+		/**
+		 * Names the entry of the request's directory it comes closest to, for
+		 * requests that failed over a typo or the casing of a file name. A module
+		 * request is looked up in the module directories, so a wrongly cased
+		 * package name is named too, and a directory the request spells out is
+		 * itself matched by casing.
+		 * @param {(hint?: string) => void} callback callback
+		 * @returns {void}
+		 */
+		const suggestClosestEntry = (callback) => {
+			const {
+				path: requestPath,
+				query,
+				fragment
+			} = parseResource(unresolvedResource);
+
+			/**
+			 * Absolute paths the resolver would have tried for a request, in the
+			 * order it tries them.
+			 * @param {string} request a request
+			 * @returns {string[]} absolute paths
+			 */
+			const lookupPaths = (request) => {
+				if (ABSOLUTE_PATH_REGEXP.test(request)) {
+					const paths = [request];
+					const firstChar = request.charCodeAt(0);
+					// A request rooted at '/' is looked up under 'resolve.roots' as well
+					if (firstChar === 47 /* "/" */ || firstChar === 92 /* "\\" */) {
+						for (const root of resolver.options.roots) {
+							paths.push(join(this.fs, root, request.slice(1)));
+						}
+					}
+					return paths;
+				}
+				if (RELATIVE_REQUEST_REGEXP.test(request)) {
+					return [join(this.fs, context, request)];
+				}
+				/** @type {string[]} */
+				const paths = [];
+				// 'preferRelative' lets a module request resolve next to its origin too
+				if (resolver.options.preferRelative) {
+					paths.push(join(this.fs, context, request));
+				}
+				for (const directory of moduleLookupDirectories(
+					this.fs,
+					context,
+					resolver.options.modules
+				)) {
+					paths.push(join(this.fs, directory, request));
+				}
+				return paths;
+			};
+
+			const absoluteRequests = lookupPaths(requestPath);
+			// Each path costs a readdir, a casing walk and a resolve, so a large
+			// alias map must not turn one failed request into unbounded work
+			for (const aliased of aliasedRequests(
+				requestPath,
+				resolver.options.alias
+			)) {
+				if (absoluteRequests.length >= MAX_SUGGESTION_CANDIDATES) break;
+				for (const path of lookupPaths(aliased)) absoluteRequests.push(path);
+			}
+			if (absoluteRequests.length > MAX_SUGGESTION_CANDIDATES) {
+				absoluteRequests.length = MAX_SUGGESTION_CANDIDATES;
+			}
+
+			/**
+			 * @param {string} prefix the request without its last segment, with the real casing
+			 * @param {string} requestedName the last segment of the request
+			 * @param {string[]} entries entries of the directory it was looked up in
+			 * @param {boolean} directoryCorrected whether the casing of `prefix` had to be corrected
+			 * @param {() => void} giveUp continues the search when nothing is close enough
+			 * @returns {void}
+			 */
+			const suggest = (
+				prefix,
+				requestedName,
+				entries,
+				directoryCorrected,
+				giveUp
+			) => {
+				const closest =
+					directoryCorrected && entries.includes(requestedName)
+						? { entry: requestedName, distance: 0 }
+						: findClosestEntry(
+								requestedName,
+								entries,
+								resolver.options.extensions
+							);
+				if (!closest) return giveUp();
+				const existing = prefix + closest.entry;
+				// The query and fragment select what to do with the file, so they
+				// belong in a request the user is meant to copy — but not in a
+				// sentence about what is on disk
+				const suggestion = existing + query + fragment;
+				const characters =
+					closest.distance === 1
+						? "1 character"
+						: `${closest.distance} characters`;
+				// A corrected directory is not part of `entry`, so the whole path has
+				// to be named for the sentence to account for every difference
+				const difference =
+					closest.distance === 0
+						? directoryCorrected
+							? `'${existing}' exists and differs from the request only in casing. Case-sensitive filesystems (most Linux ones) fail to resolve it, even when the same build succeeds on a case-insensitive one.`
+							: `'${closest.entry}' exists in that directory and differs from the request only in casing. Case-sensitive filesystems (most Linux ones) fail to resolve it, even when the same build succeeds on a case-insensitive one.`
+						: directoryCorrected
+							? `'${prefix}' differs from the request only in casing, and '${closest.entry}' is the closest name in it. It differs from the request by ${characters}, ignoring case and file extension.`
+							: `'${closest.entry}' is the closest name in that directory. It differs from the request by ${characters}, ignoring case and file extension.`;
+				// Offering a request that fails too would only be a second error, so the
+				// resolver has the last word. That keeps the hint aligned with every
+				// resolve option, not just the ones consulted to find the entry.
+				resolver.resolve(
+					contextInfo,
+					context,
+					suggestion,
+					resolveContext,
+					(suggestionError, resolved) => {
+						if (suggestionError || !resolved) return giveUp();
+						callback(`Did you mean '${suggestion}'?
+${difference}`);
+					}
+				);
+			};
+
+			/**
+			 * @param {number} index index into `absoluteRequests`
+			 * @returns {void}
+			 */
+			const next = (index) => {
+				if (index >= absoluteRequests.length) return callback();
+				const absoluteRequest = absoluteRequests[index];
+				const directory = dirname(this.fs, absoluteRequest);
+				const requestedName = relative(this.fs, directory, absoluteRequest);
+				// A request ending in '.' or '..' names a directory, not an entry in one.
+				if (!requestPath.endsWith(requestedName)) return next(index + 1);
+				const prefix = requestPath.slice(
+					0,
+					requestPath.length - requestedName.length
+				);
+				this.fs.readdir(directory, (err, entries) => {
+					if (!err && entries) {
+						return suggest(
+							prefix,
+							requestedName,
+							/** @type {string[]} */ (entries),
+							false,
+							() => next(index + 1)
+						);
+					}
+					// The directory is missing, so only a directory the request spells
+					// out itself can be the wrongly cased one
+					if (!namesDirectories(prefix)) return next(index + 1);
+					findCaseMismatch(this.fs, directory, (mismatch) => {
+						if (!mismatch) return next(index + 1);
+						const fixedPrefix = applyCaseCorrections(
+							prefix,
+							mismatch.corrections
+						);
+						if (fixedPrefix === undefined) return next(index + 1);
+						this.fs.readdir(mismatch.path, (realError, realEntries) => {
+							if (realError || !realEntries) return next(index + 1);
+							suggest(
+								fixedPrefix,
+								requestedName,
+								/** @type {string[]} */ (realEntries),
+								true,
+								() => next(index + 1)
+							);
+						});
+					});
+				});
+			};
+			next(0);
+		};
+
 		asyncLib.parallel(
 			[
 				(callback) => {
@@ -1345,7 +1740,11 @@ If changing the source code is not an option there is also a resolve options cal
 			],
 			(err, hints) => {
 				if (err) return callback(err);
-				callback(null, /** @type {string[]} */ (hints).filter(Boolean));
+				const resolveHints = /** @type {string[]} */ (hints).filter(Boolean);
+				// The hints above explain why an existing file was rejected and name it
+				// themselves, so only look for a similar name when none of them applied.
+				if (resolveHints.length > 0) return callback(null, resolveHints);
+				suggestClosestEntry((hint) => callback(null, hint ? [hint] : []));
 			}
 		);
 	}
@@ -1491,6 +1890,52 @@ If changing the source code is not an option there is also a resolve options cal
 		);
 	}
 
+	/**
+	 * Runs `prepareModuleType` for a type once, so a plugin can load what its
+	 * synchronous `createParser`/`createGenerator` tap needs. Calls back
+	 * synchronously for a type nothing taps or that is already prepared.
+	 * @param {string} type module type
+	 * @param {Callback<void>} callback signals the type is ready
+	 * @returns {void}
+	 */
+	_prepareModuleType(type, callback) {
+		const state = this._moduleTypePreparation.get(type);
+		if (state === true) return callback(null);
+		if (state !== undefined) {
+			state.push(callback);
+			return;
+		}
+		const hook = this.hooks.prepareModuleType.get(type);
+		if (hook === undefined) {
+			this._moduleTypePreparation.set(type, true);
+			return callback(null);
+		}
+		/** @type {Callback<void>[]} */
+		const waiting = [];
+		this._moduleTypePreparation.set(type, waiting);
+		hook.callAsync((err) => {
+			// a failed preparation must not be remembered as done
+			if (err) this._moduleTypePreparation.delete(type);
+			else this._moduleTypePreparation.set(type, true);
+			// every queued factorize must be resumed, so one callback throwing
+			// cannot starve the rest — the first throw is rethrown afterwards
+			waiting.unshift(callback);
+			const error = err || null;
+			/** @type {Error | undefined} */
+			let thrown;
+			for (const waitingCallback of waiting) {
+				try {
+					waitingCallback(error);
+				} catch (err_) {
+					if (thrown === undefined) {
+						thrown = /** @type {Error} */ (err_);
+					}
+				}
+			}
+			if (thrown !== undefined) throw thrown;
+		});
+	}
+
 	/**
 	 * Returns parser.
 	 * @template {string} T