webpack 5.104.1 → 5.105.1

package/lib/sharing/ConsumeSharedModule.js

@@ -17,6 +17,9 @@ const makeSerializable = require("../util/makeSerializable");
 const { rangeToString, stringifyHoley } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
 
+/** @type {WeakMap<ModuleGraph, WeakMap<ConsumeSharedModule, Module | null>>} */
+const fallbackModuleCache = new WeakMap();
+
 /** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
@@ -27,7 +30,10 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 /** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../Module").ExportsType} ExportsType */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -153,6 +159,57 @@ class ConsumeSharedModule extends Module {
 		return CONSUME_SHARED_TYPES;
 	}
 
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @returns {Module | null} fallback module
+	 */
+	_getFallbackModule(moduleGraph) {
+		let moduleCache = fallbackModuleCache.get(moduleGraph);
+		if (!moduleCache) {
+			moduleCache = new WeakMap();
+			fallbackModuleCache.set(moduleGraph, moduleCache);
+		}
+		const cached = moduleCache.get(this);
+		if (cached !== undefined) {
+			return cached;
+		}
+
+		/** @type {undefined | null | Module} */
+		let fallbackModule = null;
+
+		if (this.options.import) {
+			if (this.options.eager) {
+				const dep = this.dependencies[0];
+				if (dep) {
+					fallbackModule = moduleGraph.getModule(dep);
+				}
+			} else {
+				const block = this.blocks[0];
+				if (block && block.dependencies.length > 0) {
+					fallbackModule = moduleGraph.getModule(block.dependencies[0]);
+				}
+			}
+		}
+
+		moduleCache.set(this, fallbackModule);
+		return fallbackModule;
+	}
+
+	/**
+	 * @param {ModuleGraph} moduleGraph the module graph
+	 * @param {boolean | undefined} strict the importing module is strict
+	 * @returns {ExportsType} export type
+	 * "namespace": Exports is already a namespace object. namespace = exports.
+	 * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
+	 * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
+	 * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+	 */
+	getExportsType(moduleGraph, strict) {
+		const fallbackModule = this._getFallbackModule(moduleGraph);
+		if (!fallbackModule) return "dynamic";
+		return fallbackModule.getExportsType(moduleGraph, strict);
+	}
+
 	/**
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
@@ -186,6 +243,7 @@ class ConsumeSharedModule extends Module {
 			singleton,
 			eager
 		} = this.options;
+		/** @type {undefined | string} */
 		let fallbackCode;
 		if (request) {
 			if (eager) {
@@ -219,6 +277,7 @@ class ConsumeSharedModule extends Module {
 			args.push(fallbackCode);
 		}
 
+		/** @type {string} */
 		let fn;
 
 		if (requiredVersion) {
@@ -232,6 +291,7 @@ class ConsumeSharedModule extends Module {
 		}
 
 		const code = runtimeTemplate.returningFunction(`${fn}(${args.join(", ")})`);
+		/** @type {Sources} */
 		const sources = new Map();
 		sources.set("consume-shared", new RawSource(code));
 		return {

package/lib/sharing/ConsumeSharedPlugin.js

@@ -26,6 +26,7 @@ const {
 /** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
 /** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
 /** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
 /** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
@@ -159,7 +160,7 @@ class ConsumeSharedPlugin {
 					};
 					const directFallback =
 						config.import &&
-						/^(\.\.?(\/|$)|\/|[A-Za-z]:|\\\\)/.test(config.import);
+						/^(?:\.\.?(?:\/|$)|\/|[A-Z]:|\\\\)/i.test(config.import);
 					return Promise.all([
 						new Promise(
 							/**
@@ -170,7 +171,7 @@ class ConsumeSharedPlugin {
 									resolve();
 									return;
 								}
-								/** @typedef {ResolveContext} */
+								/** @type {ResolveContext & { fileDependencies: FileSystemDependencies, contextDependencies: FileSystemDependencies, missingDependencies: FileSystemDependencies }} */
 								const resolveContext = {
 									fileDependencies: new LazySet(),
 									contextDependencies: new LazySet(),
@@ -215,13 +216,13 @@ class ConsumeSharedPlugin {
 								}
 								let packageName = config.packageName;
 								if (packageName === undefined) {
-									if (/^(\/|[A-Za-z]:|\\\\)/.test(request)) {
+									if (/^(?:\/|[A-Z]:|\\\\)/i.test(request)) {
 										// For relative or absolute requests we don't automatically use a packageName.
 										// If wished one can specify one with the packageName option.
 										resolve();
 										return;
 									}
-									const match = /^((?:@[^\\/]+[\\/])?[^\\/]+)/.exec(request);
+									const match = /^(?:@[^\\/]+[\\/])?[^\\/]+/.exec(request);
 									if (!match) {
 										requiredVersionWarning(
 											"Unable to extract the package name from request."

package/lib/sharing/ProvideSharedModule.js

@@ -22,7 +22,9 @@ const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 /** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
+/** @typedef {import("../Module").Sources} Sources */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
+/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
@@ -147,7 +149,9 @@ class ProvideSharedModule extends Module {
 						runtimeRequirements
 					})
 		}${this._eager ? ", 1" : ""});`;
+		/** @type {Sources} */
 		const sources = new Map();
+		/** @type {CodeGenerationResultData} */
 		const data = new Map();
 		data.set("share-init", [
 			{

package/lib/sharing/ProvideSharedPlugin.js

@@ -45,29 +45,28 @@ class ProvideSharedPlugin {
 	constructor(options) {
 		validate(options);
 
-		this._provides = /** @type {[string, ProvideOptions][]} */ (
-			parseOptions(
-				options.provides,
-				(item) => {
-					if (Array.isArray(item)) {
-						throw new Error("Unexpected array of provides");
-					}
-					/** @type {ProvideOptions} */
-					const result = {
-						shareKey: item,
-						version: undefined,
-						shareScope: options.shareScope || "default",
-						eager: false
-					};
-					return result;
-				},
-				(item) => ({
-					shareKey: item.shareKey,
-					version: item.version,
-					shareScope: item.shareScope || options.shareScope || "default",
-					eager: Boolean(item.eager)
-				})
-			)
+		/** @type {[string, ProvideOptions][]} */
+		this._provides = parseOptions(
+			options.provides,
+			(item) => {
+				if (Array.isArray(item)) {
+					throw new Error("Unexpected array of provides");
+				}
+				/** @type {ProvideOptions} */
+				const result = {
+					shareKey: item,
+					version: undefined,
+					shareScope: options.shareScope || "default",
+					eager: false
+				};
+				return result;
+			},
+			(item) => ({
+				shareKey: /** @type {string} */ (item.shareKey),
+				version: item.version,
+				shareScope: item.shareScope || options.shareScope || "default",
+				eager: Boolean(item.eager)
+			})
 		);
 		this._provides.sort(([a], [b]) => {
 			if (a < b) return -1;
@@ -95,13 +94,13 @@ class ProvideSharedPlugin {
 				/** @type {Map<string, ProvideOptions>} */
 				const prefixMatchProvides = new Map();
 				for (const [request, config] of this._provides) {
-					if (/^(\/|[A-Za-z]:\\|\\\\|\.\.?(\/|$))/.test(request)) {
+					if (/^(?:\/|[A-Z]:\\|\\\\|\.\.?(?:\/|$))/i.test(request)) {
 						// relative request
 						resolvedProvideMap.set(request, {
 							config,
 							version: config.version
 						});
-					} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
+					} else if (/^(?:\/|[A-Z]:\\|\\\\)/i.test(request)) {
 						// absolute path
 						resolvedProvideMap.set(request, {
 							config,

package/lib/sharing/resolveMatchedConfigs.js

@@ -54,7 +54,7 @@ module.exports.resolveMatchedConfigs = (compilation, configs) => {
 	return Promise.all(
 		// eslint-disable-next-line array-callback-return
 		configs.map(([request, config]) => {
-			if (/^\.\.?(\/|$)/.test(request)) {
+			if (/^\.\.?(?:\/|$)/.test(request)) {
 				// relative request
 				return new Promise((resolve) => {
 					resolver.resolve(
@@ -77,7 +77,7 @@ module.exports.resolveMatchedConfigs = (compilation, configs) => {
 						}
 					);
 				});
-			} else if (/^(\/|[A-Za-z]:\\|\\\\)/.test(request)) {
+			} else if (/^(?:\/|[a-z]:\\|\\\\)/i.test(request)) {
 				// absolute path
 				resolved.set(request, config);
 			} else if (request.endsWith("/")) {

package/lib/sharing/utils.js

@@ -15,30 +15,30 @@ const { dirname, join, readJson } = require("../util/fs");
 const RE_URL_GITHUB_EXTREME_SHORT = /^[^/@:.\s][^/@:\s]*\/[^@:\s]*[^/@:\s]#\S+/;
 
 // Short url with specific protocol. eg: github:foo/bar
-const RE_GIT_URL_SHORT = /^(github|gitlab|bitbucket|gist):\/?[^/.]+\/?/i;
+const RE_GIT_URL_SHORT = /^(?:github|gitlab|bitbucket|gist):\/?[^/.]+\/?/i;
 
 // Currently supported protocols
 const RE_PROTOCOL =
-	/^((git\+)?(ssh|https?|file)|git|github|gitlab|bitbucket|gist):$/i;
+	/^(?:(?:git\+)?(?:ssh|https?|file)|git|github|gitlab|bitbucket|gist):$/i;
 
 // Has custom protocol
-const RE_CUSTOM_PROTOCOL = /^((git\+)?(ssh|https?|file)|git):\/\//i;
+const RE_CUSTOM_PROTOCOL = /^(?:(?:git\+)?(?:ssh|https?|file)|git):\/\//i;
 
 // Valid hash format for npm / yarn ...
 const RE_URL_HASH_VERSION = /#(?:semver:)?(.+)/;
 
 // Simple hostname validate
-const RE_HOSTNAME = /^(?:[^/.]+(\.[^/]+)+|localhost)$/;
+const RE_HOSTNAME = /^(?:[^/.]+(?:\.[^/]+)+|localhost)$/;
 
 // For hostname with colon. eg: ssh://user@github.com:foo/bar
 const RE_HOSTNAME_WITH_COLON =
 	/([^/@#:.]+(?:\.[^/@#:.]+)+|localhost):([^#/0-9]+)/;
 
 // Reg for url without protocol
-const RE_NO_PROTOCOL = /^([^/@#:.]+(?:\.[^/@#:.]+)+)/;
+const RE_NO_PROTOCOL = /^[^/@#:.]+(?:\.[^/@#:.]+)+/;
 
 // RegExp for version string
-const VERSION_PATTERN_REGEXP = /^([\d^=v<>~]|[*xX]$)/;
+const VERSION_PATTERN_REGEXP = /^(?:[\d^=v<>~]|[*xX]$)/;
 
 // Specific protocol for short url without normal hostname
 const PROTOCOLS_FOR_SHORT = [
@@ -248,7 +248,9 @@ function getGitUrlVersion(gitUrl) {
 
 	gitUrl = correctUrl(gitUrl);
 
+	/** @type {undefined | URL} */
 	let parsed;
+
 	try {
 		parsed = new URL(gitUrl);
 		// eslint-disable-next-line no-empty

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -386,12 +386,10 @@ const uniqueOrderedArray = (items, selector, comparator) =>
  * @returns {MappedValues<T, R>} mapped object
  */
 const mapObject = (obj, fn) => {
+	/** @type {MappedValues<T, R>} */
 	const newObj = Object.create(null);
-	for (const key of Object.keys(obj)) {
-		newObj[key] = fn(
-			obj[/** @type {keyof T} */ (key)],
-			/** @type {keyof T} */ (key)
-		);
+	for (const key of /** @type {(keyof T)[]} */ (Object.keys(obj))) {
+		newObj[key] = fn(obj[key], key);
 	}
 	return newObj;
 };
@@ -507,8 +505,8 @@ const EXTRACT_ERROR = {
 			object.details = /** @type {WebpackError} */ (error).details;
 		}
 	},
-	errorStack: (object, error) => {
-		if (typeof error !== "string") {
+	errorStack: (object, error, _context, { errorStack }) => {
+		if (typeof error !== "string" && errorStack) {
 			object.stack = error.stack;
 		}
 	},
@@ -545,6 +543,8 @@ const EXTRACT_ERROR = {
 	}
 };
 
+/** @typedef {((value: string) => boolean)} FilterItemTypeFn */
+
 /** @type {SimpleExtractors} */
 const SIMPLE_EXTRACTORS = {
 	compilation: {
@@ -587,6 +587,7 @@ const SIMPLE_EXTRACTORS = {
 				const util = require("util");
 
 				object.logging = {};
+				/** @type {Set<keyof LogType>} */
 				let acceptedTypes;
 				let collapsedGroups = false;
 				switch (logging) {
@@ -677,6 +678,7 @@ const SIMPLE_EXTRACTORS = {
 							if (depthInCollapsedGroup > 0) depthInCollapsedGroup--;
 							continue;
 						}
+						/** @type {undefined | string} */
 						let message;
 						if (entry.type === LogType.time) {
 							const [label, first, second] =
@@ -1229,7 +1231,7 @@ const SIMPLE_EXTRACTORS = {
 			const codeGenerated = compilation.codeGeneratedModules.has(module);
 			const buildTimeExecuted =
 				compilation.buildTimeExecutedModules.has(module);
-			/** @type {{[x: string]: number}} */
+			/** @type {{ [x: string]: number }} */
 			const sizes = {};
 			for (const sourceType of module.getSourceTypes()) {
 				sizes[sourceType] = module.size(sourceType);
@@ -1826,6 +1828,7 @@ const getTotalItems = (children) => {
  */
 const collapse = (children) => {
 	// After collapse each child must take exactly one line
+	/** @type {Children<T>[]} */
 	const newChildren = [];
 	for (const child of children) {
 		if (child.children) {
@@ -1872,6 +1875,7 @@ const spaceLimited = (
 	/** @type {number[]} */
 	const groupSizes = [];
 	// This are the items, which take 1 line each
+	/** @type {Children<T>[]} */
 	const items = [];
 	// The total of group sizes
 	let groupsSize = 0;
@@ -1907,6 +1911,7 @@ const spaceLimited = (
 		if (limit < max) {
 			// calculate how much we are over the size limit
 			// this allows to approach the limit faster
+			/** @type {number} */
 			let oversize;
 			// If each group would take 1 line the total would be below the maximum
 			// collapse some groups, keep items
@@ -2097,6 +2102,8 @@ const GROUP_PATH_REGEXP = /(.+)[/\\][^/\\]+?(?:\?|(?: \+ \d+ modules?)?$)/;
  * @typedef {BaseGroup & { children: T[], size: number }} BaseGroupWithChildren
  */
 
+/** @typedef {(name: string, asset: StatsAsset) => boolean} AssetFilterItemFn */
+
 /**
  * @typedef {{
  * _: (groupConfigs: GroupConfig<KnownStatsAsset, BaseGroup & { filteredChildren: number, size: number } | BaseGroupWithChildren<KnownStatsAsset>>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
@@ -2256,6 +2263,8 @@ const ASSETS_GROUPERS = {
  * }} ModulesGroupers
  */
 
+/** @typedef {(name: string, module: StatsModule, type: "module" | "chunk" | "root-of-chunk" | "nested") => boolean} ModuleFilterItemTypeFn */
+
 /**
  * @type {(type: ExcludeModulesType) => ModulesGroupers}
  */
@@ -2377,6 +2386,7 @@ const MODULES_GROUPERS = (type) => ({
 					const pathMatch =
 						groupModulesByPath && GROUP_PATH_REGEXP.exec(resource);
 					const path = pathMatch ? pathMatch[1].split(/[/\\]/) : [];
+					/** @type {string[]} */
 					const keys = [];
 					if (groupModulesByPath) {
 						if (extension) {
@@ -2442,9 +2452,7 @@ const MODULES_GROUPERS = (type) => ({
 });
 
 /**
- * @typedef {{
- * groupReasonsByOrigin: (groupConfigs: GroupConfig<KnownStatsModuleReason, BaseGroup & { module: string, children: KnownStatsModuleReason[], active: boolean }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void
- * }} ModuleReasonsGroupers
+ * @typedef {{ groupReasonsByOrigin: (groupConfigs: GroupConfig<KnownStatsModuleReason, BaseGroup & { module: string, children: KnownStatsModuleReason[], active: boolean }>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void }} ModuleReasonsGroupers
  */
 
 /** @type {ModuleReasonsGroupers} */
@@ -2541,7 +2549,7 @@ const sortByField = (field) => {
 /**
  * @typedef {{
  * assetsSort: (comparators: Comparator<Asset>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
- * _: (comparators: Comparator<Asset>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void
+ * _: (comparators: Comparator<Asset>[], context: StatsFactoryContext, options: NormalizedStatsOptions) => void,
  * }} AssetSorters
  */
 

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -245,6 +245,7 @@ const COMPILATION_SIMPLE_PRINTERS = {
 			nameMessage && versionMessage
 				? `${nameMessage} (${versionMessage})`
 				: versionMessage || nameMessage || "webpack";
+		/** @type {string} */
 		let statusMessage;
 		if (errorsMessage && warningsMessage) {
 			statusMessage = `compiled with ${errorsMessage} and ${warningsMessage}`;
@@ -587,8 +588,7 @@ const MODULE_SIMPLE_PRINTERS = {
 };
 
 /**
- * @typedef {Printers<KnownStatsModuleIssuer, "moduleIssuer"> &
- * Printers<KnownStatsModuleIssuer["profile"], "moduleIssuer.profile", "moduleIssuer">} ModuleIssuerPrinters
+ * @typedef {Printers<KnownStatsModuleIssuer, "moduleIssuer"> & Printers<KnownStatsModuleIssuer["profile"], "moduleIssuer.profile", "moduleIssuer">} ModuleIssuerPrinters
  */
 
 /** @type {ModuleIssuerPrinters} */
@@ -598,8 +598,7 @@ const MODULE_ISSUER_PRINTERS = {
 };
 
 /**
- * @typedef {Printers<KnownStatsModuleReason, "moduleReason"> &
- * { ["moduleReason.filteredChildren"]?: SimplePrinter<number, "moduleReason"> }} ModuleReasonsPrinters
+ * @typedef {Printers<KnownStatsModuleReason, "moduleReason"> & { ["moduleReason.filteredChildren"]?: SimplePrinter<number, "moduleReason"> }} ModuleReasonsPrinters
  */
 
 /** @type {ModuleReasonsPrinters} */
@@ -799,7 +798,7 @@ const ERROR_PRINTERS = {
 	"error.file": (file, { bold }) => bold(file),
 	"error.moduleName": (moduleName, { bold }) =>
 		moduleName.includes("!")
-			? `${bold(moduleName.replace(/^(\s|\S)*!/, ""))} (${moduleName})`
+			? `${bold(moduleName.replace(/^([\s\S])*!/, ""))} (${moduleName})`
 			: `${bold(moduleName)}`,
 	"error.loc": (loc, { green }) => green(loc),
 	"error.message": (message, { bold, formatError }) =>
@@ -1193,6 +1192,7 @@ const joinOneLine = (items) =>
  * @returns {string} result
  */
 const joinInBrackets = (items) => {
+	/** @type {string[]} */
 	const res = [];
 	let mode = 0;
 	for (const item of items) {
@@ -1296,6 +1296,7 @@ const joinError =
 /** @type {Record<string, SimpleElementJoiner>} */
 const SIMPLE_ELEMENT_JOINERS = {
 	compilation: (items) => {
+		/** @type {string[]} */
 		const result = [];
 		let lastNeedMore = false;
 		for (const item of items) {

package/lib/stats/StatsFactory.js

@@ -161,7 +161,7 @@ class StatsFactory {
 	/**
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} 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 {Caches<H>} cache cache
 	 * @param {string} type type
@@ -197,7 +197,7 @@ class StatsFactory {
 	/**
 	 * @template {StatsFactoryHooks[keyof StatsFactoryHooks]} T
 	 * @template {T 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 {T} hookMap hook map
 	 * @param {Caches<H>} cache cache
 	 * @param {string} type type

package/lib/url/URLParserPlugin.js

@@ -54,9 +54,7 @@ const isMetaUrl = (parser, arg) => {
 	return true;
 };
 
-/**
- * @type {WeakMap<NewExpressionNode, BasicEvaluatedExpression | undefined>}
- */
+/** @type {WeakMap<NewExpressionNode, BasicEvaluatedExpression | undefined>} */
 const getEvaluatedExprCache = new WeakMap();
 
 /**
@@ -95,6 +93,7 @@ class URLParserPlugin {
 	 * @param {JavascriptParserOptions} options options
 	 */
 	constructor(options) {
+		/** @type {JavascriptParserOptions} */
 		this.options = options;
 	}
 
@@ -167,6 +166,7 @@ class URLParserPlugin {
 			const evaluatedExpr = getEvaluatedExpr(expr, parser);
 			if (!evaluatedExpr) return;
 
+			/** @type {string | undefined} */
 			let request;
 
 			// static URL
@@ -190,7 +190,9 @@ class URLParserPlugin {
 			if (this.options.dynamicUrl === false) return;
 
 			// context URL
+			/** @type {undefined | RegExp} */
 			let include;
+			/** @type {undefined | RegExp} */
 			let exclude;
 
 			if (importOptions) {

package/lib/util/AppendOnlyStackedSet.js

@@ -0,0 +1,57 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+/**
+ * @template T
+ */
+class AppendOnlyStackedSet {
+	/**
+	 * @param {Set<T>[]} sets an optional array of sets
+	 */
+	constructor(sets = []) {
+		/** @type {Set<T>[]} */
+		this._sets = sets;
+		/** @type {Set<T> | undefined} */
+		this._current = undefined;
+	}
+
+	/**
+	 * @param {T} el element
+	 */
+	add(el) {
+		if (!this._current) {
+			this._current = new Set();
+			this._sets.push(this._current);
+		}
+		this._current.add(el);
+	}
+
+	/**
+	 * @param {T} el element
+	 * @returns {boolean} result
+	 */
+	has(el) {
+		for (const set of this._sets) {
+			if (set.has(el)) return true;
+		}
+		return false;
+	}
+
+	clear() {
+		this._sets = [];
+		if (this._current) this._current.clear();
+	}
+
+	/**
+	 * @returns {AppendOnlyStackedSet<T>} child
+	 */
+	createChild() {
+		return new AppendOnlyStackedSet(this._sets.length ? [...this._sets] : []);
+	}
+}
+
+module.exports = AppendOnlyStackedSet;

package/lib/util/Hash.js

@@ -6,6 +6,7 @@
 "use strict";
 
 /** @typedef {import("../../declarations/WebpackOptions").HashDigest} Encoding */
+/** @typedef {string | typeof Hash} HashFunction */
 
 class Hash {
 	/* istanbul ignore next */

package/lib/util/IterableHelpers.js

@@ -11,6 +11,7 @@
  * @returns {T | undefined} last item
  */
 const last = (set) => {
+	/** @type {T | undefined} */
 	let last;
 	for (const item of set) last = item;
 	return last;

package/lib/util/LazyBucketSortedSet.js

@@ -56,6 +56,7 @@ class LazyBucketSortedSet {
 		this._keys = new SortableSet(undefined, comparator);
 		/** @type {Map<K, Entry<T, K>>} */
 		this._map = new Map();
+		/** @type {Set<T>} */
 		this._unsortedItems = new Set();
 		this.size = 0;
 	}

package/lib/util/LazySet.js

@@ -222,6 +222,7 @@ class LazySet {
 	 */
 	static deserialize({ read }) {
 		const count = read();
+		/** @type {T[]} */
 		const items = [];
 		for (let i = 0; i < count; i++) {
 			items.push(read());

package/lib/util/ParallelismFactorCalculator.js

@@ -35,6 +35,7 @@ class ParallelismFactorCalculator {
 			a < b ? -1 : 1
 		);
 		const parallelism = segments.map(() => 0);
+		/** @type {number[]} */
 		const rangeStartIndices = [];
 		for (let i = 0; i < this._rangePoints.length; i += 2) {
 			const start = this._rangePoints[i];

package/lib/util/SortableSet.js

@@ -88,6 +88,7 @@ class SortableSet extends Set {
 			return;
 		}
 
+		/** @type {T[]} */
 		const sortedArray = [...this].sort(sortFn);
 		super.clear();
 		for (let i = 0; i < sortedArray.length; i += 1) {

package/lib/util/StringXor.js

@@ -62,6 +62,7 @@ class StringXor {
 		const valueLen = value.length;
 		if (valueLen < len) {
 			const newValue = (this._value = Buffer.allocUnsafe(len));
+			/** @type {number} */
 			let i;
 			for (i = 0; i < valueLen; i++) {
 				newValue[i] = value[i] ^ str.charCodeAt(i);