webpack 5.104.1 → 5.105.0

package/lib/util/comparators.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { getFullModuleName } = require("../ids/IdHelpers");
 const { compareRuntime } = require("./runtime");
 
 /** @typedef {import("../Chunk")} Chunk */
@@ -13,6 +14,7 @@ const { compareRuntime } = require("./runtime");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../dependencies/HarmonyImportSideEffectDependency")} HarmonyImportSideEffectDependency */
@@ -316,6 +318,19 @@ const compareModulesByIdOrIdentifier = (chunkGraph, a, b) => {
 	return compareIds(a.identifier(), b.identifier());
 };
 
+/**
+ * Compare modules by their full name. This differs from comparing by identifier in that the values have been normalized to be relative to the compiler context.
+ * @param {{ context: string, root: object }} compiler the compiler, used for context and cache
+ * @param {Module} a module
+ * @param {Module} b module
+ * @returns {-1 | 0 | 1} compare result
+ */
+const compareModulesByFullName = (compiler, a, b) => {
+	const aName = getFullModuleName(a, compiler.context, compiler.root);
+	const bName = getFullModuleName(b, compiler.context, compiler.root);
+	return compareIds(aName, bName);
+};
+
 /**
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {Chunk} a chunk
@@ -519,7 +534,7 @@ const sortWithSourceOrder = (
 	dependencySourceOrderMap,
 	onDependencyReSort
 ) => {
-	/** @type {{dep: Dependency, main: number, sub: number}[]} */
+	/** @type {{ dep: Dependency, main: number, sub: number }[]} */
 	const withSourceOrder = [];
 	/** @type {number[]} */
 	const positions = [];
@@ -590,6 +605,11 @@ module.exports.compareIterables = compareIterables;
 
 module.exports.compareLocations = compareLocations;
 
+/** @type {ParameterizedComparator<Compiler, Module>} */
+module.exports.compareModulesByFullName = createCachedParameterizedComparator(
+	compareModulesByFullName
+);
+
 /** @type {ParameterizedComparator<ChunkGraph, Module>} */
 module.exports.compareModulesById =
 	createCachedParameterizedComparator(compareModulesById);

package/lib/util/compileBooleanMatcher.js

@@ -252,10 +252,10 @@ const itemsToRegexp = (itemsArr) => {
 
 	// special case for 2 items with common suffix
 	if (finishedItems.length === 0 && items.size === 2) {
-		/** @type {Iterator<string>} */
+		/** @type {SetIterator<string>} */
 		const it = items[Symbol.iterator]();
-		const a = it.next().value;
-		const b = it.next().value;
+		const a = /** @type {string} */ (it.next().value);
+		const b = /** @type {string} */ (it.next().value);
 		if (a.length > 0 && b.length > 0 && a.slice(-1) === b.slice(-1)) {
 			return `${itemsToRegexp([a.slice(0, -1), b.slice(0, -1)])}${quoteMeta(
 				a.slice(-1)

package/lib/util/concatenate.js

@@ -110,7 +110,7 @@ function findNewName(oldName, usedNamed1, usedNamed2, extraInfo) {
 
 	// Remove uncool stuff
 	extraInfo = extraInfo.replace(
-		/\.+\/|(\/index)?\.([a-zA-Z0-9]{1,4})($|\s|\?)|\s*\+\s*\d+\s*modules/g,
+		/\.+\/|(?:\/index)?\.[a-zA-Z0-9]{1,4}(?:$|\s|\?)|\s*\+\s*\d+\s*modules/g,
 		""
 	);
 
@@ -199,9 +199,10 @@ const RESERVED_NAMES = new Set(
 );
 
 /** @typedef {{ usedNames: UsedNames, alreadyCheckedScopes: ScopeSet }} ScopeInfo */
+/** @typedef {Map<string, ScopeInfo>} UsedNamesInScopeInfo */
 
 /**
- * @param {Map<string, ScopeInfo>} usedNamesInScopeInfo used names in scope info
+ * @param {UsedNamesInScopeInfo} usedNamesInScopeInfo used names in scope info
  * @param {string} module module identifier
  * @param {string} id export id
  * @returns {ScopeInfo} info

package/lib/util/conventions.js

@@ -20,7 +20,7 @@ const preserveCamelCase = (string) => {
 	for (let i = 0; i < result.length; i++) {
 		const character = result[i];
 
-		if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+		if (isLastCharLower && /\p{Lu}/u.test(character)) {
 			result = `${result.slice(0, i)}-${result.slice(i)}`;
 			isLastCharLower = false;
 			isLastLastCharUpper = isLastCharUpper;
@@ -29,7 +29,7 @@ const preserveCamelCase = (string) => {
 		} else if (
 			isLastCharUpper &&
 			isLastLastCharUpper &&
-			/[\p{Ll}]/u.test(character)
+			/\p{Ll}/u.test(character)
 		) {
 			result = `${result.slice(0, i - 1)}-${result.slice(i - 1)}`;
 			isLastLastCharUpper = isLastCharUpper;
@@ -84,6 +84,7 @@ module.exports.camelCase = (input) => {
  * @returns {string[]} results
  */
 module.exports.cssExportConvention = (input, convention) => {
+	/** @type {Set<string>} */
 	const set = new Set();
 	if (typeof convention === "function") {
 		set.add(convention(input));

package/lib/util/deterministicGrouping.js

@@ -100,6 +100,7 @@ const subtractSizeFrom = (total, size) => {
  * @returns {Sizes} total size
  */
 const sumSize = (nodes) => {
+	/** @type {Sizes} */
 	const sum = Object.create(null);
 	for (const node of nodes) {
 		addSizeTo(sum, node.size);
@@ -145,7 +146,7 @@ const isTooSmall = (size, minSize) => {
  * @returns {Types} set of types that are too small
  */
 const getTooSmallTypes = (size, minSize) => {
-	/** @typedef {Types} */
+	/** @type {Types} */
 	const types = new Set();
 	for (const key of Object.keys(size)) {
 		const s = size[key];
@@ -223,9 +224,13 @@ class Group {
 	 * @returns {Node<T>[] | undefined} removed nodes
 	 */
 	popNodes(filter) {
+		/** @type {Node<T>[]} */
 		const newNodes = [];
+		/** @type {Similarities} */
 		const newSimilarities = [];
+		/** @type {Node<T>[]} */
 		const resultNodes = [];
+		/** @type {undefined | Node<T>} */
 		let lastNode;
 		for (let i = 0; i < this.nodes.length; i++) {
 			const node = this.nodes[i];
@@ -260,6 +265,7 @@ const getSimilarities = (nodes) => {
 	// calculate similarities between lexically adjacent nodes
 	/** @type {Similarities} */
 	const similarities = [];
+	/** @type {undefined | Node<T>} */
 	let last;
 	for (const node of nodes) {
 		if (last !== undefined) {
@@ -399,6 +405,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				// going minSize from left and right
 				// at least one node need to be included otherwise we get stuck
 				let left = 1;
+				/** @type {Sizes} */
 				const leftSize = Object.create(null);
 				addSizeTo(leftSize, group.nodes[0].size);
 				while (left < group.nodes.length && isTooSmall(leftSize, minSize)) {
@@ -406,6 +413,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 					left++;
 				}
 				let right = group.nodes.length - 2;
+				/** @type {Sizes} */
 				const rightSize = Object.create(null);
 				addSizeTo(rightSize, group.nodes[group.nodes.length - 1].size);
 				while (right >= 0 && isTooSmall(rightSize, minSize)) {
@@ -425,6 +433,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 				if (left - 1 > right) {
 					// We try to remove some problematic nodes to "fix" that
+					/** @type {Sizes} */
 					let prevSize;
 					if (right < group.nodes.length - left) {
 						subtractSizeFrom(rightSize, group.nodes[right + 1].size);
@@ -490,6 +499,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 
 				// create two new groups for left and right area
 				// and queue them up
+				/** @type {Node<T>[]} */
 				const rightNodes = [group.nodes[right + 1]];
 				/** @type {Similarities} */
 				const rightSimilarities = [];
@@ -501,6 +511,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 				}
 				queue.push(new Group(rightNodes, rightSimilarities));
 
+				/** @type {Node<T>[]} */
 				const leftNodes = [group.nodes[0]];
 				/** @type {Similarities} */
 				const leftSimilarities = [];
@@ -523,6 +534,7 @@ module.exports = ({ maxSize, minSize, items, getSize, getKey }) => {
 	});
 
 	// give every group a name
+	/** @type {Set<string>} */
 	const usedNames = new Set();
 	for (let i = 0; i < result.length; i++) {
 		const group = result[i];

package/lib/util/extractSourceMap.js

@@ -10,16 +10,10 @@ const urlUtils = require("url");
 const { isAbsolute, join } = require("./fs");
 
 /** @typedef {import("./fs").InputFileSystem} InputFileSystem */
-
-/**
- * @typedef {(input: string | Buffer<ArrayBufferLike>, resourcePath: string, fs: InputFileSystem) => Promise<{source: string | Buffer<ArrayBufferLike>, sourceMap: string | RawSourceMap | undefined, fileDependencies: string[]}>} SourceMapExtractorFunction
- */
-
+/** @typedef {string | Buffer<ArrayBufferLike>} StringOrBuffer */
+/** @typedef {(input: StringOrBuffer, resourcePath: string, fs: InputFileSystem) => Promise<{ source: StringOrBuffer, sourceMap: string | RawSourceMap | undefined, fileDependencies: string[] }>} SourceMapExtractorFunction */
 /** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
-
-/**
- * @typedef {(resourcePath: string) => Promise<string | Buffer<ArrayBufferLike>>} ReadResource
- */
+/** @typedef {(resourcePath: string) => Promise<StringOrBuffer>} ReadResource */
 
 /**
  * @typedef {object} SourceMappingURL
@@ -52,6 +46,7 @@ const sourceMappingURLRegex = new RegExp(
  */
 function getSourceMappingURL(code) {
 	const lines = code.split(/^/m);
+	/** @type {RegExpMatchArray | null | undefined} */
 	let match;
 
 	for (let i = lines.length - 1; i >= 0; i--) {
@@ -104,13 +99,14 @@ function isURL(value) {
  * @param {ReadResource} readResource read resource function
  * @param {string[]} possibleRequests array of possible file paths
  * @param {string} errorsAccumulator accumulated error messages
- * @returns {Promise<{path: string, data?: string}>} source content promise
+ * @returns {Promise<{ path: string, data?: string }>} source content promise
  */
 async function fetchPathsFromURL(
 	readResource,
 	possibleRequests,
 	errorsAccumulator = ""
 ) {
+	/** @type {StringOrBuffer} */
 	let result;
 
 	try {
@@ -146,7 +142,7 @@ async function fetchPathsFromURL(
  * @param {string} url source URL
  * @param {string=} sourceRoot source root directory
  * @param {boolean=} skipReading whether to skip reading file content
- * @returns {Promise<{sourceURL: string, sourceContent?: string | Buffer<ArrayBufferLike>}>} source content promise
+ * @returns {Promise<{ sourceURL: string, sourceContent?: StringOrBuffer }>} source content promise
  */
 async function fetchFromURL(
 	readResource,
@@ -181,9 +177,11 @@ async function fetchFromURL(
 	if (isAbsolute(url)) {
 		let sourceURL = path.normalize(url);
 
+		/** @type {undefined | StringOrBuffer} */
 		let sourceContent;
 
 		if (!skipReading) {
+			/** @type {string[]} */
 			const possibleRequests = [sourceURL];
 
 			if (url.startsWith("/")) {
@@ -203,6 +201,7 @@ async function fetchFromURL(
 
 	// 4. Relative path
 	const sourceURL = getAbsolutePath(context, url, sourceRoot || "");
+	/** @type {undefined | StringOrBuffer} */
 	let sourceContent;
 
 	if (!skipReading) {
@@ -214,10 +213,10 @@ async function fetchFromURL(
 
 /**
  * Extract source map from code content
- * @param {string | Buffer<ArrayBufferLike>} stringOrBuffer The input code content as string or buffer
+ * @param {StringOrBuffer} stringOrBuffer The input code content as string or buffer
  * @param {string} resourcePath The path to the resource file
  * @param {ReadResource} readResource The read resource function
- * @returns {Promise<{source: string | Buffer<ArrayBufferLike>, sourceMap: string | RawSourceMap | undefined}>} Promise resolving to extracted source map information
+ * @returns {Promise<{ source: StringOrBuffer, sourceMap: string | RawSourceMap | undefined }>} Promise resolving to extracted source map information
  */
 async function extractSourceMap(stringOrBuffer, resourcePath, readResource) {
 	const input =

package/lib/util/fs.js

@@ -8,7 +8,9 @@
 const path = require("path");
 
 /** @typedef {import("../../declarations/WebpackOptions").WatchOptions} WatchOptions */
-/** @typedef {import("../FileSystemInfo").FileSystemInfoEntry} FileSystemInfoEntry */
+/** @typedef {import("watchpack").Entry} Entry */
+/** @typedef {import("watchpack").OnlySafeTimeEntry} OnlySafeTimeEntry */
+/** @typedef {import("watchpack").ExistenceOnlyTimeEntry} ExistenceOnlyTimeEntry */
 
 /**
  * @template T
@@ -83,7 +85,7 @@ const path = require("path");
 /** @typedef {(err: NodeJS.ErrnoException | null, result?: number) => void} NumberCallback */
 /** @typedef {(err: NodeJS.ErrnoException | Error | null, result?: JsonObject) => void} ReadJsonCallback */
 
-/** @typedef {Map<string, FileSystemInfoEntry | "ignore">} TimeInfoEntries */
+/** @typedef {Map<string, Entry | OnlySafeTimeEntry | ExistenceOnlyTimeEntry | null | "ignore">} TimeInfoEntries */
 
 /** @typedef {Set<string>} Changes */
 /** @typedef {Set<string>} Removals */
@@ -201,7 +203,7 @@ const path = require("path");
 
 /**
  * @typedef {{
- * (path: PathLike, options?: { encoding: BufferEncoding | null, withFileTypes?: false | undefined, recursive?: boolean | undefined; } | BufferEncoding | null): string[],
+ * (path: PathLike, options?: { encoding: BufferEncoding | null, withFileTypes?: false | undefined, recursive?: boolean | undefined } | BufferEncoding | null): string[],
  * (path: PathLike, options: { encoding: "buffer", withFileTypes?: false | undefined, recursive?: boolean | undefined } | "buffer"): Buffer[],
  * (path: PathLike, options?: (ObjectEncodingOptions & { withFileTypes?: false | undefined, recursive?: boolean | undefined }) | BufferEncoding | null): string[] | Buffer[],
  * (path: PathLike, options: ObjectEncodingOptions & { withFileTypes: true, recursive?: boolean | undefined }): Dirent[],
@@ -225,8 +227,8 @@ const path = require("path");
  * (path: PathLike, options: StatSyncOptions & { bigint: true, throwIfNoEntry: false }): IBigIntStats | undefined,
  * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined }): IStats,
  * (path: PathLike, options: StatSyncOptions & { bigint: true }): IBigIntStats,
- * (path: PathLike,  options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: false | undefined }): IStats | IBigIntStats,
- * (path: PathLike,  options?: StatSyncOptions): IStats | IBigIntStats | undefined,
+ * (path: PathLike, options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: false | undefined }): IStats | IBigIntStats,
+ * (path: PathLike, options?: StatSyncOptions): IStats | IBigIntStats | undefined,
  * }} StatSync
  */
 
@@ -246,8 +248,8 @@ const path = require("path");
  * (path: PathLike, options: StatSyncOptions & { bigint: true, throwIfNoEntry: false }): IBigIntStats | undefined,
  * (path: PathLike, options?: StatSyncOptions & { bigint?: false | undefined }): IStats,
  * (path: PathLike, options: StatSyncOptions & { bigint: true }): IBigIntStats,
- * (path: PathLike,  options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: false | undefined }): IStats | IBigIntStats,
- * (path: PathLike,  options?: StatSyncOptions): IStats | IBigIntStats | undefined,
+ * (path: PathLike, options: StatSyncOptions & { bigint: boolean, throwIfNoEntry?: false | undefined }): IStats | IBigIntStats,
+ * (path: PathLike, options?: StatSyncOptions): IStats | IBigIntStats | undefined,
  * }} LStatSync
  */
 
@@ -256,7 +258,7 @@ const path = require("path");
  * (path: PathLike, options: EncodingOption, callback: StringCallback): void,
  * (path: PathLike, options: BufferEncodingOption, callback: BufferCallback): void,
  * (path: PathLike, options: EncodingOption, callback: StringOrBufferCallback): void,
- * (path: PathLike, callback: StringCallback): void;
+ * (path: PathLike, callback: StringCallback): void,
  * }} RealPath
  */
 
@@ -324,21 +326,14 @@ const path = require("path");
 /**
  * @typedef {{
  * (file: PathLike, options: MakeDirectoryOptions & { recursive: true }, callback: StringCallback): void,
- * (file: PathLike, options: Mode | (MakeDirectoryOptions & { recursive?: false | undefined; }) | null | undefined, callback: NoParamCallback): void,
+ * (file: PathLike, options: Mode | (MakeDirectoryOptions & { recursive?: false | undefined }) | null | undefined, callback: NoParamCallback): void,
  * (file: PathLike, options: Mode | MakeDirectoryOptions | null | undefined, callback: StringCallback): void,
  * (file: PathLike, callback: NoParamCallback): void,
  * }} Mkdir
  */
 
 /**
- * @typedef {{ maxRetries?: number | undefined, recursive?: boolean | undefined, retryDelay?: number | undefined }} RmDirOptions
- */
-
-/**
- * @typedef {{
- * (file: PathLike, callback: NoParamCallback): void,
- * (file: PathLike, options: RmDirOptions, callback: NoParamCallback): void,
- * }} Rmdir
+ * @typedef {{ (file: PathLike, callback: NoParamCallback): void }} Rmdir
  */
 
 /**
@@ -405,7 +400,7 @@ const path = require("path");
  */
 
 /**
- * @typedef {FSImplementation & { write: (...args: EXPECTED_ANY[]) => EXPECTED_ANY; close?: (...args: EXPECTED_ANY[]) => EXPECTED_ANY }} CreateWriteStreamFSImplementation
+ * @typedef {FSImplementation & { write: (...args: EXPECTED_ANY[]) => EXPECTED_ANY, close?: (...args: EXPECTED_ANY[]) => EXPECTED_ANY }} CreateWriteStreamFSImplementation
  */
 
 /**
@@ -422,7 +417,7 @@ const path = require("path");
 
 /**
  * @typedef {{
- * (file: PathLike, flags: OpenMode | undefined,  mode: Mode | undefined | null, callback: NumberCallback): void,
+ * (file: PathLike, flags: OpenMode | undefined, mode: Mode | undefined | null, callback: NumberCallback): void,
  * (file: PathLike, flags: OpenMode | undefined, callback: NumberCallback): void,
  * (file: PathLike, callback: NumberCallback): void,
  * }} Open
@@ -613,6 +608,7 @@ const readJson = (fs, p, callback) => {
 	}
 	fs.readFile(p, (err, buf) => {
 		if (err) return callback(err);
+		/** @type {JsonObject} */
 		let data;
 		try {
 			data = JSON.parse(/** @type {Buffer} */ (buf).toString("utf8"));

package/lib/util/hash/BatchedHash.js

@@ -17,8 +17,11 @@ class BatchedHash extends Hash {
 	 */
 	constructor(hash) {
 		super();
+		/** @type {undefined | string} */
 		this.string = undefined;
+		/** @type {undefined | Encoding} */
 		this.encoding = undefined;
+		/** @type {Hash} */
 		this.hash = hash;
 	}
 

package/lib/util/hash/BulkUpdateHash.js

@@ -15,7 +15,7 @@ const BULK_SIZE = 3;
 
 // We are using an object instead of a Map as this will stay static during the runtime
 // so access to it can be optimized by v8
-/** @type {{[key: string]: Map<string, string>}} */
+/** @type {{ [key: string]: Map<string, string> }} */
 const digestCaches = {};
 
 class BulkUpdateHash extends Hash {
@@ -25,12 +25,17 @@ class BulkUpdateHash extends Hash {
 	 */
 	constructor(hashOrFactory, hashKey) {
 		super();
+		/** @type {undefined | string} */
 		this.hashKey = hashKey;
 		if (typeof hashOrFactory === "function") {
+			/** @type {undefined | HashFactory} */
 			this.hashFactory = hashOrFactory;
+			/** @type {undefined | Hash} */
 			this.hash = undefined;
 		} else {
+			/** @type {undefined | HashFactory} */
 			this.hashFactory = undefined;
+			/** @type {undefined | Hash} */
 			this.hash = hashOrFactory;
 		}
 		this.buffer = "";
@@ -103,6 +108,7 @@ class BulkUpdateHash extends Hash {
 	 * @returns {string | Buffer} digest
 	 */
 	digest(encoding) {
+		/** @type {undefined | Map<string, string | Buffer>} */
 		let digestCache;
 		const buffer = this.buffer;
 		if (this.hash === undefined) {

package/lib/util/hash/hash-digest.js

@@ -49,6 +49,7 @@ const encode = (buffer, base) => {
 		value = (value << EIGHT) | BigInt(buffer[i]);
 	}
 	// Convert to baseX string efficiently using array
+	/** @type {string[]} */
 	const digits = [];
 	if (value === ZERO) return ENCODE_TABLE[base][0];
 	while (value > ZERO) {

package/lib/util/hash/wasm-hash.js

@@ -13,6 +13,14 @@ const Hash = require("../Hash");
 // ~3 makes sure that it's always a block of 4 chars, so avoid partially encoded bytes for base64
 const MAX_SHORT_STRING = Math.floor((65536 - 64) / 4) & ~3;
 
+/**
+ * @typedef {object} WasmExports
+ * @property {WebAssembly.Memory} memory
+ * @property {() => void} init
+ * @property {(length: number) => void} update
+ * @property {(length: number) => void} final
+ */
+
 class WasmHash extends Hash {
 	/**
 	 * @param {WebAssembly.Instance} instance wasm instance
@@ -23,13 +31,19 @@ class WasmHash extends Hash {
 	constructor(instance, instancesPool, chunkSize, digestSize) {
 		super();
 
-		const exports = /** @type {EXPECTED_ANY} */ (instance.exports);
+		const exports = /** @type {WasmExports} */ (instance.exports);
 		exports.init();
+		/** @type {WasmExports} */
 		this.exports = exports;
+		/** @type {Buffer} */
 		this.mem = Buffer.from(exports.memory.buffer, 0, 65536);
+		/** @type {number} */
 		this.buffered = 0;
+		/** @type {WebAssembly.Instance[]} */
 		this.instancesPool = instancesPool;
+		/** @type {number} */
 		this.chunkSize = chunkSize;
+		/** @type {number} */
 		this.digestSize = digestSize;
 	}
 
@@ -85,6 +99,7 @@ class WasmHash extends Hash {
 	 */
 	_updateWithShortString(data, encoding) {
 		const { exports, buffered, mem, chunkSize } = this;
+		/** @type {number} */
 		let endPos;
 		if (data.length < 70) {
 			// eslint-disable-next-line unicorn/text-encoding-identifier-case

package/lib/util/identifier.js

@@ -6,7 +6,7 @@
 
 const path = require("path");
 
-const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
+const WINDOWS_ABS_PATH_REGEXP = /^[a-z]:[\\/]/i;
 const SEGMENTS_SPLIT_REGEXP = /([|!])/;
 const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
 
@@ -165,7 +165,8 @@ const makeCacheable = (realFn) => {
  * @returns {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} cacheable function with context
  */
 const makeCacheableWithContext = (fn) => {
-	/** @type {WeakMap<AssociatedObjectForCache, Map<string, Map<string, string>>>} */
+	/** @typedef {Map<string, Map<string, string>>} InnerCache */
+	/** @type {WeakMap<AssociatedObjectForCache, InnerCache>} */
 	const cache = new WeakMap();
 
 	/** @type {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} */
@@ -178,6 +179,7 @@ const makeCacheableWithContext = (fn) => {
 			cache.set(associatedObjectForCache, innerCache);
 		}
 
+		/** @type {undefined | string} */
 		let cachedResult;
 		let innerSubCache = innerCache.get(context);
 		if (innerSubCache === undefined) {
@@ -196,6 +198,7 @@ const makeCacheableWithContext = (fn) => {
 
 	/** @type {BindCacheForContext} */
 	cachedFn.bindCache = (associatedObjectForCache) => {
+		/** @type {undefined | InnerCache} */
 		let innerCache;
 		if (associatedObjectForCache) {
 			innerCache = cache.get(associatedObjectForCache);
@@ -213,6 +216,7 @@ const makeCacheableWithContext = (fn) => {
 		 * @returns {string} the returned relative path
 		 */
 		const boundFn = (context, identifier) => {
+			/** @type {undefined | string} */
 			let cachedResult;
 			let innerSubCache = innerCache.get(context);
 			if (innerSubCache === undefined) {
@@ -234,6 +238,7 @@ const makeCacheableWithContext = (fn) => {
 
 	/** @type {BindContextCacheForContext} */
 	cachedFn.bindContextCache = (context, associatedObjectForCache) => {
+		/** @type {undefined | Map<string, string>} */
 		let innerSubCache;
 		if (associatedObjectForCache) {
 			let innerCache = cache.get(associatedObjectForCache);

package/lib/util/magicComment.js

@@ -16,7 +16,7 @@ module.exports.createMagicCommentContext = () =>
 		codeGeneration: { strings: false, wasm: false }
 	});
 module.exports.webpackCommentRegExp = new RegExp(
-	/(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/
+	/(^|\W)webpack[A-Z][A-Za-z]+:/
 );
 
 // regexp to match at least one "magic comment"

package/lib/util/propertyName.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const SAFE_IDENTIFIER = /^[_a-zA-Z$][_a-zA-Z$0-9]*$/;
+const SAFE_IDENTIFIER = /^[_a-z$][_a-z$0-9]*$/i;
 const RESERVED_IDENTIFIER = new Set([
 	"break",
 	"case",

package/lib/util/registerExternalSerializer.js

@@ -168,6 +168,7 @@ register(
 		deserialize({ read }) {
 			const source = new ReplaceSource(read(), read());
 			const len = read();
+			/** @type {number[]} */
 			const startEndBuffer = [];
 			for (let i = 0; i < len; i++) {
 				startEndBuffer.push(read(), read());

package/lib/util/runtime.js

@@ -10,7 +10,8 @@ const SortableSet = require("./SortableSet");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
 
-/** @typedef {string | SortableSet<string> | undefined} RuntimeSpec */
+/** @typedef {SortableSet<string>} RuntimeSpecSortableSet */
+/** @typedef {string | RuntimeSpecSortableSet | undefined} RuntimeSpec */
 /** @typedef {RuntimeSpec | boolean} RuntimeCondition */
 
 /**
@@ -20,7 +21,9 @@ const SortableSet = require("./SortableSet");
  * @returns {RuntimeSpec} runtime
  */
 const getEntryRuntime = (compilation, name, options) => {
+	/** @type {EntryOptions["dependOn"]} */
 	let dependOn;
+	/** @type {EntryOptions["runtime"]} */
 	let runtime;
 	if (options) {
 		({ dependOn, runtime } = options);
@@ -194,6 +197,7 @@ const mergeRuntime = (a, b) => {
 		return a;
 	} else if (typeof a === "string") {
 		if (typeof b === "string") {
+			/** @type {RuntimeSpecSortableSet} */
 			const set = new SortableSet();
 			set.add(a);
 			set.add(b);
@@ -201,16 +205,19 @@ const mergeRuntime = (a, b) => {
 		} else if (b.has(a)) {
 			return b;
 		}
+		/** @type {RuntimeSpecSortableSet} */
 		const set = new SortableSet(b);
 		set.add(a);
 		return set;
 	}
 	if (typeof b === "string") {
 		if (a.has(b)) return a;
+		/** @type {RuntimeSpecSortableSet} */
 		const set = new SortableSet(a);
 		set.add(b);
 		return set;
 	}
+	/** @type {RuntimeSpecSortableSet} */
 	const set = new SortableSet(a);
 	for (const item of b) set.add(item);
 	if (set.size === a.size) return a;
@@ -271,14 +278,17 @@ const mergeRuntimeOwned = (a, b) => {
 		if (typeof b === "string") {
 			return b;
 		}
+		/** @type {RuntimeSpecSortableSet} */
 		return new SortableSet(b);
 	} else if (typeof a === "string") {
 		if (typeof b === "string") {
+			/** @type {RuntimeSpecSortableSet} */
 			const set = new SortableSet();
 			set.add(a);
 			set.add(b);
 			return set;
 		}
+		/** @type {RuntimeSpecSortableSet} */
 		const set = new SortableSet(b);
 		set.add(a);
 		return set;
@@ -315,6 +325,7 @@ const intersectRuntime = (a, b) => {
 		if (a.has(b)) return b;
 		return;
 	}
+	/** @type {RuntimeSpecSortableSet} */
 	const set = new SortableSet();
 	for (const item of b) {
 		if (a.has(item)) set.add(item);
@@ -354,10 +365,12 @@ const subtractRuntime = (a, b) => {
 				if (item !== b) return item;
 			}
 		}
+		/** @type {RuntimeSpecSortableSet} */
 		const set = new SortableSet(a);
 		set.delete(b);
 		return set;
 	}
+	/** @type {RuntimeSpecSortableSet} */
 	const set = new SortableSet();
 	for (const item of a) {
 		if (!b.has(item)) set.add(item);
@@ -394,6 +407,7 @@ const filterRuntime = (runtime, filter) => {
 	if (typeof runtime === "string") return filter(runtime);
 	let some = false;
 	let every = true;
+	/** @type {RuntimeSpec} */
 	let result;
 	for (const r of runtime) {
 		const v = filter(r);