webpack 5.104.1 → 5.105.0

package/bin/webpack.js

@@ -57,9 +57,11 @@ const isInstalled = (packageName) => {
 	} while (dir !== (dir = path.dirname(dir)));
 
 	// https://github.com/nodejs/node/blob/v18.9.1/lib/internal/modules/cjs/loader.js#L1274
-	// eslint-disable-next-line no-warning-comments
-	// @ts-ignore
-	for (const internalPath of require("module").globalPaths) {
+	const { globalPaths } =
+		/** @type {typeof import("module") & { globalPaths: string[] }} */
+		(require("module"));
+
+	for (const internalPath of globalPaths) {
 		try {
 			if (fs.statSync(path.join(internalPath, packageName)).isDirectory()) {
 				return true;
@@ -81,6 +83,7 @@ const runCli = (cli) => {
 
 	const pkgPath = require.resolve(`${cli.package}/package.json`);
 
+	/** @type {Record<string, EXPECTED_ANY> & { type: string, bin: Record<string, string> }} */
 	const pkg = require(pkgPath);
 
 	if (pkg.type === "module" || /\.mjs/i.test(pkg.bin[cli.binName])) {

package/lib/APIPlugin.js

@@ -16,6 +16,8 @@ const {
 const RuntimeGlobals = require("./RuntimeGlobals");
 const WebpackError = require("./WebpackError");
 const ConstDependency = require("./dependencies/ConstDependency");
+const ModuleInitFragmentDependency = require("./dependencies/ModuleInitFragmentDependency");
+const RuntimeRequirementsDependency = require("./dependencies/RuntimeRequirementsDependency");
 const BasicEvaluatedExpression = require("./javascript/BasicEvaluatedExpression");
 const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 const {
@@ -32,7 +34,7 @@ const GetFullHashRuntimeModule = require("./runtime/GetFullHashRuntimeModule");
 /** @typedef {import("./javascript/JavascriptParser").Range} Range */
 
 /**
- * @returns {Record<string, {expr: string, req: string[] | null, type?: string, assign: boolean}>} replacements
+ * @returns {Record<string, { expr: string, req: string[] | null, type?: string, assign: boolean }>} replacements
  */
 function getReplacements() {
 	return {
@@ -160,6 +162,10 @@ class APIPlugin {
 					ConstDependency,
 					new ConstDependency.Template()
 				);
+				compilation.dependencyTemplates.set(
+					ModuleInitFragmentDependency,
+					new ModuleInitFragmentDependency.Template()
+				);
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.chunkName)
@@ -201,6 +207,40 @@ class APIPlugin {
 				 * @param {JavascriptParser} parser the parser
 				 */
 				const handler = (parser) => {
+					parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator) => {
+						if (
+							parser.scope.topLevelScope === true &&
+							declarator.id.type === "Identifier" &&
+							declarator.id.name === "module"
+						) {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).moduleArgument =
+								"__webpack_module__";
+						}
+					});
+
+					parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
+						if (parser.scope.topLevelScope === true) {
+							if (
+								statement.type === "FunctionDeclaration" &&
+								statement.id &&
+								statement.id.name === "module"
+							) {
+								/** @type {BuildInfo} */
+								(parser.state.module.buildInfo).moduleArgument =
+									"__webpack_module__";
+							} else if (
+								statement.type === "ClassDeclaration" &&
+								statement.id &&
+								statement.id.name === "module"
+							) {
+								/** @type {BuildInfo} */
+								(parser.state.module.buildInfo).moduleArgument =
+									"__webpack_module__";
+							}
+						}
+					});
+
 					for (const key of Object.keys(REPLACEMENTS)) {
 						const info = REPLACEMENTS[key];
 						parser.hooks.expression.for(key).tap(PLUGIN_NAME, (expression) => {
@@ -275,13 +315,28 @@ class APIPlugin {
 							/** @type {BuildInfo} */
 							(parser.state.module.buildInfo).moduleConcatenationBailout =
 								"__webpack_module__.id";
-							const dep = new ConstDependency(
-								`${parser.state.module.moduleArgument}.id`,
-								/** @type {Range} */ (expr.range),
-								[RuntimeGlobals.moduleId]
-							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-							parser.state.module.addPresentationalDependency(dep);
+							const moduleArgument = parser.state.module.moduleArgument;
+							if (moduleArgument === "__webpack_module__") {
+								const dep = new RuntimeRequirementsDependency([
+									RuntimeGlobals.moduleId
+								]);
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								parser.state.module.addPresentationalDependency(dep);
+							} else {
+								const initDep = new ModuleInitFragmentDependency(
+									`var __webpack_internal_module_id__ = ${moduleArgument}.id;\n`,
+									[RuntimeGlobals.moduleId],
+									"__webpack_internal_module_id__"
+								);
+								parser.state.module.addPresentationalDependency(initDep);
+								const dep = new ConstDependency(
+									"__webpack_internal_module_id__",
+									/** @type {Range} */ (expr.range),
+									[]
+								);
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								parser.state.module.addPresentationalDependency(dep);
+							}
 							return true;
 						});
 
@@ -291,13 +346,28 @@ class APIPlugin {
 							/** @type {BuildInfo} */
 							(parser.state.module.buildInfo).moduleConcatenationBailout =
 								"__webpack_module__";
-							const dep = new ConstDependency(
-								parser.state.module.moduleArgument,
-								/** @type {Range} */ (expr.range),
-								[RuntimeGlobals.module]
-							);
-							dep.loc = /** @type {DependencyLocation} */ (expr.loc);
-							parser.state.module.addPresentationalDependency(dep);
+							const moduleArgument = parser.state.module.moduleArgument;
+							if (moduleArgument === "__webpack_module__") {
+								const dep = new RuntimeRequirementsDependency([
+									RuntimeGlobals.module
+								]);
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								parser.state.module.addPresentationalDependency(dep);
+							} else {
+								const initDep = new ModuleInitFragmentDependency(
+									`var __webpack_internal_module__ = ${moduleArgument};\n`,
+									[RuntimeGlobals.module],
+									"__webpack_internal_module__"
+								);
+								parser.state.module.addPresentationalDependency(initDep);
+								const dep = new ConstDependency(
+									"__webpack_internal_module__",
+									/** @type {Range} */ (expr.range),
+									[]
+								);
+								dep.loc = /** @type {DependencyLocation} */ (expr.loc);
+								parser.state.module.addPresentationalDependency(dep);
+							}
 							return true;
 						});
 					parser.hooks.evaluateTypeof

package/lib/AbstractMethodError.js

@@ -48,6 +48,7 @@ function Message() {
 class AbstractMethodError extends WebpackError {
 	constructor() {
 		super(new Message().message);
+		/** @type {string} */
 		this.name = "AbstractMethodError";
 	}
 }

package/lib/AsyncDependenciesBlock.js

@@ -16,7 +16,7 @@ const makeSerializable = require("./util/makeSerializable");
 /** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("./util/Hash")} Hash */
 
-/** @typedef {(ChunkGroupOptions & { entryOptions?: EntryOptions }) | string} GroupOptions */
+/** @typedef {(ChunkGroupOptions & { entryOptions?: EntryOptions } & { circular?: boolean }) | string} GroupOptions */
 
 class AsyncDependenciesBlock extends DependenciesBlock {
 	/**
@@ -31,9 +31,14 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		} else if (!groupOptions) {
 			groupOptions = { name: undefined };
 		}
+		if (typeof groupOptions.circular !== "boolean") {
+			// default allow circular references
+			groupOptions.circular = true;
+		}
 		this.groupOptions = groupOptions;
 		this.loc = loc;
 		this.request = request;
+		/** @type {undefined | string} */
 		this._stringifiedGroupOptions = undefined;
 	}
 
@@ -55,6 +60,13 @@ class AsyncDependenciesBlock extends DependenciesBlock {
 		}
 	}
 
+	/**
+	 * @returns {boolean} Whether circular references are allowed
+	 */
+	get circular() {
+		return Boolean(this.groupOptions.circular);
+	}
+
 	/**
 	 * @param {Hash} hash the hash used to track dependencies
 	 * @param {UpdateHashContext} context context

package/lib/AsyncDependencyToInitialChunkError.js

@@ -22,6 +22,7 @@ class AsyncDependencyToInitialChunkError extends WebpackError {
 			`It's not allowed to load an initial chunk on demand. The chunk name "${chunkName}" is already used by an entrypoint.`
 		);
 
+		/** @type {string} */
 		this.name = "AsyncDependencyToInitialChunkError";
 		this.module = module;
 		this.loc = loc;

package/lib/AutomaticPrefetchPlugin.js

@@ -29,7 +29,7 @@ class AutomaticPrefetchPlugin {
 				);
 			}
 		);
-		/** @type {{context: string | null, request: string}[] | null} */
+		/** @type {{ context: string | null, request: string }[] | null} */
 		let lastModules = null;
 		compiler.hooks.afterCompile.tap(PLUGIN_NAME, (compilation) => {
 			lastModules = [];

package/lib/BannerPlugin.js

@@ -11,6 +11,7 @@ const ModuleFilenameHelpers = require("./ModuleFilenameHelpers");
 const Template = require("./Template");
 const createSchemaValidation = require("./util/create-schema-validation");
 
+/** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../declarations/plugins/BannerPlugin").BannerFunction} BannerFunction */
 /** @typedef {import("../declarations/plugins/BannerPlugin").BannerPluginArgument} BannerPluginArgument */
 /** @typedef {import("./Compilation").PathData} PathData */
@@ -88,6 +89,7 @@ class BannerPlugin {
 			undefined,
 			options
 		);
+		/** @type {WeakMap<Source, { source: ConcatSource, comment: string }>} */
 		const cache = new WeakMap();
 		const stage =
 			this.options.stage || Compilation.PROCESS_ASSETS_STAGE_ADDITIONS;

package/lib/CacheFacade.js

@@ -13,7 +13,7 @@ const mergeEtags = require("./cache/mergeEtags");
 /** @typedef {import("./Cache")} Cache */
 /** @typedef {import("./Cache").Etag} Etag */
 /** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
-/** @typedef {typeof import("./util/Hash")} HashConstructor */
+/** @typedef {import("./util/Hash").HashFunction} HashFunction */
 
 /**
  * @template T
@@ -196,7 +196,7 @@ class CacheFacade {
 	/**
 	 * @param {Cache} cache the root cache
 	 * @param {string} name the child cache name
-	 * @param {(string | HashConstructor)=} hashFunction the hash function to use
+	 * @param {HashFunction=} hashFunction the hash function to use
 	 */
 	constructor(cache, name, hashFunction) {
 		this._cache = cache;

package/lib/CaseSensitiveModulesWarning.js

@@ -63,6 +63,7 @@ This can lead to unexpected behavior when compiling on a filesystem with other c
 Use equal casing. Compare these module identifiers:
 ${modulesList}`);
 
+		/** @type {string} */
 		this.name = "CaseSensitiveModulesWarning";
 		this.module = sortedModules[0];
 	}

package/lib/Chunk.js

@@ -719,7 +719,7 @@ class Chunk {
 	 * @returns {Record<string, ChunkId[]>} a record object of names to lists of child ids(?)
 	 */
 	getChildIdsByOrders(chunkGraph, filterFn) {
-		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
+		/** @type {Map<string, { order: number, group: ChunkGroup }[]>} */
 		const lists = new Map();
 		for (const group of this.groupsIterable) {
 			if (group.chunks[group.chunks.length - 1] === this) {
@@ -777,11 +777,13 @@ class Chunk {
 	 * @returns {{ onChunks: Chunk[], chunks: Chunks }[] | undefined} referenced chunks for a specific type
 	 */
 	getChildrenOfTypeInOrder(chunkGraph, type) {
+		/** @type {{ order: number, group: ChunkGroup, childGroup: ChunkGroup }[]} */
 		const list = [];
 		for (const group of this.groupsIterable) {
 			for (const childGroup of group.childrenIterable) {
 				const order =
-					childGroup.options[/** @type {keyof ChunkGroupOptions} */ (type)];
+					/** @type {number} */
+					(childGroup.options[/** @type {keyof ChunkGroupOptions} */ (type)]);
 				if (order === undefined) continue;
 				list.push({
 					order,
@@ -792,12 +794,14 @@ class Chunk {
 		}
 		if (list.length === 0) return;
 		list.sort((a, b) => {
-			const cmp =
-				/** @type {number} */ (b.order) - /** @type {number} */ (a.order);
+			const cmp = b.order - a.order;
 			if (cmp !== 0) return cmp;
 			return a.group.compareTo(chunkGraph, b.group);
 		});
+		/** @typedef {{ onChunks: Chunk[], chunks: Chunks }} Entry */
+		/** @type {Entry[]} */
 		const result = [];
+		/** @type {undefined | Entry} */
 		let lastEntry;
 		for (const { group, childGroup } of list) {
 			if (lastEntry && lastEntry.onChunks === group.chunks) {

package/lib/ChunkGraph.js

@@ -43,7 +43,7 @@ const {
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./RuntimeModule")} RuntimeModule */
-/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./util/Hash").HashFunction} HashFunction */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 /** @type {ReadonlySet<string>} */
@@ -69,7 +69,9 @@ class ModuleHashInfo {
 	 * @param {string} renderedHash rendered hash
 	 */
 	constructor(hash, renderedHash) {
+		/** @type {string} */
 		this.hash = hash;
+		/** @type {string} */
 		this.renderedHash = renderedHash;
 	}
 }
@@ -95,10 +97,11 @@ const getModuleRuntimes = (chunks) => {
 
 /**
  * @param {SourceTypesByModule | undefined} sourceTypesByModule sourceTypesByModule
- * @returns {(set: SortableSet<Module>) => Map<string, SortableSet<Module>>} modules by source type
+ * @returns {ModulesBySourceType} modules by source type
  */
 const modulesBySourceType = (sourceTypesByModule) => (set) => {
-	/** @type {Map<SourceType, SortableSet<Module>>} */
+	/** @typedef {SortableSet<Module>} ModuleSortableSet */
+	/** @type {Map<SourceType, ModuleSortableSet>} */
 	const map = new Map();
 	for (const module of set) {
 		const sourceTypes =
@@ -107,6 +110,7 @@ const modulesBySourceType = (sourceTypesByModule) => (set) => {
 		for (const sourceType of sourceTypes) {
 			let innerSet = map.get(sourceType);
 			if (innerSet === undefined) {
+				/** @type {ModuleSortableSet} */
 				innerSet = new SortableSet();
 				map.set(sourceType, innerSet);
 			}
@@ -122,6 +126,10 @@ const modulesBySourceType = (sourceTypesByModule) => (set) => {
 	}
 	return map;
 };
+
+/** @typedef {(set: SortableSet<Module>) => Map<string, SortableSet<Module>>} ModulesBySourceType */
+
+/** @type {ModulesBySourceType} */
 const defaultModulesBySourceType = modulesBySourceType(undefined);
 
 /**
@@ -164,11 +172,14 @@ const getModulesSize = (modules) => {
 	return size;
 };
 
+/** @typedef {Record<string, number>} SizesOfModules */
+
 /**
  * @param {Iterable<Module>} modules the sortable Set to get the size of
- * @returns {Record<string, number>} the sizes of the modules
+ * @returns {SizesOfModules} the sizes of the modules
  */
 const getModulesSizes = (modules) => {
+	/** @type {SizesOfModules} */
 	const sizes = Object.create(null);
 	for (const module of modules) {
 		for (const type of module.getSourceTypes()) {
@@ -199,6 +210,7 @@ const isAvailableChunk = (a, b) => {
 /** @typedef {Set<Chunk>} EntryInChunks */
 /** @typedef {Set<Chunk>} RuntimeInChunks */
 /** @typedef {string | number} ModuleId */
+/** @typedef {RuntimeSpecMap<Set<string>, RuntimeRequirements>} ChunkGraphRuntimeRequirements */
 
 class ChunkGraphModule {
 	constructor() {
@@ -212,7 +224,7 @@ class ChunkGraphModule {
 		this.hashes = undefined;
 		/** @type {ModuleId | null} */
 		this.id = null;
-		/** @type {RuntimeSpecMap<Set<string>, RuntimeRequirements> | undefined} */
+		/** @type {ChunkGraphRuntimeRequirements | undefined} */
 		this.runtimeRequirements = undefined;
 		/** @type {RuntimeSpecMap<string, bigint> | undefined} */
 		this.graphHashes = undefined;
@@ -242,7 +254,7 @@ class ChunkGraphChunk {
 		this.runtimeRequirements = undefined;
 		/** @type {Set<string>} */
 		this.runtimeRequirementsInTree = new Set();
-
+		/** @type {ModulesBySourceType} */
 		this._modulesBySourceType = defaultModulesBySourceType;
 	}
 }
@@ -251,13 +263,14 @@ class ChunkGraphChunk {
 /** @typedef {Record<ModuleId, string>} IdToHashMap */
 /** @typedef {Record<ChunkId, IdToHashMap>} ChunkModuleHashMap */
 /** @typedef {Record<ChunkId, ModuleId[]>} ChunkModuleIdMap */
+/** @typedef {Record<ChunkId, boolean>} ChunkConditionMap */
 
 /** @typedef {(a: Module, b: Module) => -1 | 0 | 1} ModuleComparator */
 
 class ChunkGraph {
 	/**
 	 * @param {ModuleGraph} moduleGraph the module graph
-	 * @param {string | Hash} hashFunction the hash function to use
+	 * @param {HashFunction} hashFunction the hash function to use
 	 */
 	constructor(moduleGraph, hashFunction = DEFAULTS.HASH_FUNCTION) {
 		/**
@@ -809,6 +822,7 @@ class ChunkGraph {
 			)) {
 				if (filterFn(module)) {
 					if (idToHashMap === undefined) {
+						/** @type {IdToHashMap} */
 						idToHashMap = Object.create(null);
 						chunkModuleHashMap[/** @type {ChunkId} */ (asyncChunk.id)] =
 							/** @type {IdToHashMap} */
@@ -830,9 +844,10 @@ class ChunkGraph {
 	/**
 	 * @param {Chunk} chunk the chunk
 	 * @param {ChunkFilterPredicate} filterFn function used to filter chunks
-	 * @returns {Record<ChunkId, boolean>} chunk map
+	 * @returns {ChunkConditionMap} chunk condition map
 	 */
 	getChunkConditionMap(chunk, filterFn) {
+		/** @type {ChunkConditionMap} */
 		const map = Object.create(null);
 		for (const c of chunk.getAllReferencedChunks()) {
 			map[/** @type {ChunkId} */ (c.id)] = filterFn(c, this);
@@ -848,6 +863,7 @@ class ChunkGraph {
 	 */
 	hasModuleInGraph(chunk, filterFn, filterChunkFn) {
 		const queue = new Set(chunk.groupsIterable);
+		/** @type {Set<Chunk>} */
 		const chunksProcessed = new Set();
 
 		for (const chunkGroup of queue) {
@@ -1556,6 +1572,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 		const cgm = this._getChunkGraphModule(module);
 		const runtimeRequirementsMap = cgm.runtimeRequirements;
 		if (runtimeRequirementsMap === undefined) {
+			/** @type {ChunkGraphRuntimeRequirements} */
 			const map = new RuntimeSpecMap();
 			// TODO avoid cloning item and track ownership instead
 			map.set(runtime, transferOwnership ? items : new Set(items));
@@ -1740,6 +1757,7 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 			} else {
 				// cspell:word Tnamespace
 				for (const connection of connections) {
+					/** @type {Set<ConnectionState>} */
 					const states = new Set();
 					let stateInfo = "";
 					forEachRuntime(
@@ -1754,7 +1772,10 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 					if (states.size === 1) {
 						const state = first(states);
 						if (state === false) continue;
-						stateInfo = activeStateToString(state);
+						stateInfo = activeStateToString(
+							/** @type {ConnectionState} */
+							(state)
+						);
 					}
 					processConnection(connection, stateInfo);
 				}

package/lib/ChunkGroup.js

@@ -56,7 +56,7 @@ const sortById = (a, b) => {
 /**
  * @param {OriginRecord} a the first comparator in sort
  * @param {OriginRecord} b the second comparator in sort
- * @returns {1 | -1| 0} returns sorting order as index
+ * @returns {1 | -1 | 0} returns sorting order as index
  */
 const sortOrigin = (a, b) => {
 	const aIdent = a.module ? a.module.identifier() : "";
@@ -79,13 +79,15 @@ class ChunkGroup {
 		}
 		/** @type {number} */
 		this.groupDebugId = debugId++;
-		this.options = /** @type {ChunkGroupOptions} */ (options);
+		/** @type {ChunkGroupOptions} */
+		this.options = options;
 		/** @type {SortableSet<ChunkGroup>} */
 		this._children = new SortableSet(undefined, sortById);
 		/** @type {SortableSet<ChunkGroup>} */
 		this._parents = new SortableSet(undefined, sortById);
 		/** @type {SortableSet<ChunkGroup>} */
 		this._asyncEntrypoints = new SortableSet(undefined, sortById);
+		/** @type {SortableSet<AsyncDependenciesBlock>} */
 		this._blocks = new SortableSet();
 		/** @type {Chunk[]} */
 		this.chunks = [];
@@ -429,6 +431,7 @@ class ChunkGroup {
 	 * @returns {string[]} the files contained this chunk group
 	 */
 	getFiles() {
+		/** @type {Set<string>} */
 		const files = new Set();
 
 		for (const chunk of this.chunks) {
@@ -505,7 +508,7 @@ class ChunkGroup {
 	 * @returns {Record<string, ChunkGroup[]>} mapping from children type to ordered list of ChunkGroups
 	 */
 	getChildrenByOrders(moduleGraph, chunkGraph) {
-		/** @type {Map<string, {order: number, group: ChunkGroup}[]>} */
+		/** @type {Map<string, { order: number, group: ChunkGroup }[]>} */
 		const lists = new Map();
 		for (const childGroup of this._children) {
 			for (const key of Object.keys(childGroup.options)) {

package/lib/ChunkRenderError.js

@@ -19,6 +19,7 @@ class ChunkRenderError extends WebpackError {
 	constructor(chunk, file, error) {
 		super();
 
+		/** @type {string} */
 		this.name = "ChunkRenderError";
 		this.error = error;
 		this.message = error.message;
@@ -28,4 +29,5 @@ class ChunkRenderError extends WebpackError {
 	}
 }
 
+/** @type {typeof ChunkRenderError} */
 module.exports = ChunkRenderError;

package/lib/CleanPlugin.js

@@ -70,6 +70,7 @@ const mergeAssets = (as1, as2) => {
  * @returns {Set<string>} Set of directory paths
  */
 function getDirectories(assets) {
+	/** @type {Set<string>} */
 	const directories = new Set();
 	/**
 	 * @param {string} filename asset filename
@@ -143,6 +144,7 @@ const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
  * @returns {Diff} diff
  */
 const getDiffToOldAssets = (currentAssets, oldAssets) => {
+	/** @type {Diff} */
 	const diff = new Set();
 	const now = Date.now();
 	for (const [asset, ts] of oldAssets) {
@@ -416,7 +418,8 @@ class CleanPlugin {
 				const currentAssets = new Map();
 				const now = Date.now();
 				for (const asset of Object.keys(compilation.assets)) {
-					if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset)) continue;
+					if (/^[a-z]:\\|^\/|^\\\\/i.test(asset)) continue;
+					/** @type {string} */
 					let normalizedAsset;
 					let newNormalizedAsset = asset.replace(/\\/g, "/");
 					do {

package/lib/CodeGenerationError.js

@@ -18,12 +18,18 @@ class CodeGenerationError extends WebpackError {
 	constructor(module, error) {
 		super();
 
+		/** @type {string} */
 		this.name = "CodeGenerationError";
+		/** @type {Module} */
+		this.module = module;
+		/** @type {Error} */
 		this.error = error;
+		/** @type {string} */
 		this.message = error.message;
+		/** @type {string} */
 		this.details = error.stack;
-		this.module = module;
 	}
 }
 
+/** @type {typeof CodeGenerationError} */
 module.exports = CodeGenerationError;

package/lib/CodeGenerationResults.js

@@ -17,16 +17,17 @@ const { RuntimeSpecMap, runtimeToString } = require("./util/runtime");
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("./Module").CodeGenerationResultData} CodeGenerationResultData */
 /** @typedef {import("./Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
-/** @typedef {typeof import("./util/Hash")} Hash */
+/** @typedef {import("./util/Hash").HashFunction} HashFunction */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
 class CodeGenerationResults {
 	/**
-	 * @param {string | Hash} hashFunction the hash function to use
+	 * @param {HashFunction} hashFunction the hash function to use
 	 */
 	constructor(hashFunction = DEFAULTS.HASH_FUNCTION) {
 		/** @type {Map<Module, RuntimeSpecMap<CodeGenerationResult>>} */
 		this.map = new Map();
+		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 	}
 
@@ -152,7 +153,13 @@ Caller might not support runtime-dependent code generation (opt-out via optimiza
 	 * @returns {void}
 	 */
 	add(module, runtime, result) {
-		const map = getOrInsert(this.map, module, () => new RuntimeSpecMap());
+		const map = getOrInsert(
+			this.map,
+			module,
+			() =>
+				/** @type {RuntimeSpecMap<CodeGenerationResult>} */
+				new RuntimeSpecMap()
+		);
 		map.set(runtime, result);
 	}
 }

package/lib/CommentCompilationWarning.js

@@ -18,8 +18,9 @@ class CommentCompilationWarning extends WebpackError {
 	constructor(message, loc) {
 		super(message);
 
+		/** @type {string} */
 		this.name = "CommentCompilationWarning";
-
+		/** @type {DependencyLocation} */
 		this.loc = loc;
 	}
 }