webpack 5.101.3 → 5.102.0

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -8,7 +8,6 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
 /** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../MainTemplate")} MainTemplate */
 
 class StartupEntrypointRuntimeModule extends RuntimeModule {
 	/**

package/lib/runtime/SystemContextRuntimeModule.js

@@ -7,8 +7,6 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
-/** @typedef {import("../Compilation")} Compilation */
-
 class SystemContextRuntimeModule extends RuntimeModule {
 	constructor() {
 		super("__system_context__");

package/lib/runtime/ToBinaryRuntimeModule.js

@@ -0,0 +1,64 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+const Template = require("../Template");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class ToBinaryRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("to binary");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const fn = RuntimeGlobals.toBinary;
+		const { runtimeTemplate } = compilation;
+
+		// Inspired by esbuild
+
+		const isNodePlatform = compilation.compiler.platform.node;
+		const isWebPlatform = compilation.compiler.platform.web;
+		const isNeutralPlatform = runtimeTemplate.isNeutralPlatform();
+
+		return Template.asString([
+			"// define to binary helper",
+			`${fn} = ${isNeutralPlatform ? "typeof Buffer !== 'undefined' ? " : ""}${
+				isNodePlatform || isNeutralPlatform
+					? `${runtimeTemplate.returningFunction("new Uint8Array(Buffer.from(base64, 'base64'))", "base64")}`
+					: ""
+			} ${isNeutralPlatform ? ": " : ""}${
+				isWebPlatform || isNeutralPlatform
+					? `(${runtimeTemplate.basicFunction("", [
+							"var table = new Uint8Array(128);",
+							"for (var i = 0; i < 64; i++) table[i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i * 4 - 205] = i;",
+							`return ${runtimeTemplate.basicFunction("base64", [
+								"var n = base64.length, bytes = new Uint8Array((n - (base64[n - 1] == '=') - (base64[n - 2] == '=')) * 3 / 4 | 0);",
+								"for (var i = 0, j = 0; i < n;) {",
+								Template.indent([
+									"var c0 = table[base64.charCodeAt(i++)], c1 = table[base64.charCodeAt(i++)];",
+									"var c2 = table[base64.charCodeAt(i++)], c3 = table[base64.charCodeAt(i++)];",
+									"bytes[j++] = (c0 << 2) | (c1 >> 4);",
+									"bytes[j++] = (c1 << 4) | (c2 >> 2);",
+									"bytes[j++] = (c2 << 6) | c3;"
+								]),
+								"}",
+								"return bytes"
+							])}`
+						])})();`
+					: ""
+			}`
+		]);
+	}
+}
+
+module.exports = ToBinaryRuntimeModule;

package/lib/schemes/DataUriPlugin.js

@@ -6,37 +6,10 @@
 "use strict";
 
 const NormalModule = require("../NormalModule");
+const { URIRegEx, decodeDataURI } = require("../util/dataURL");
 
 /** @typedef {import("../Compiler")} Compiler */
 
-// data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
-// http://www.ietf.org/rfc/rfc2397.txt
-const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64)?)?,(.*)$/i;
-
-/**
- * @param {string} uri data URI
- * @returns {Buffer | null} decoded data
- */
-const decodeDataURI = (uri) => {
-	const match = URIRegEx.exec(uri);
-	if (!match) return null;
-
-	const isBase64 = match[3];
-	const body = match[4];
-
-	if (isBase64) {
-		return Buffer.from(body, "base64");
-	}
-
-	// CSS allows to use `data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg"><rect width="100%" height="100%" style="stroke: rgb(223,224,225); stroke-width: 2px; fill: none; stroke-dasharray: 6px 3px" /></svg>`
-	// so we return original body if we can't `decodeURIComponent`
-	try {
-		return Buffer.from(decodeURIComponent(body), "ascii");
-	} catch (_) {
-		return Buffer.from(body, "ascii");
-	}
-};
-
 const PLUGIN_NAME = "DataUriPlugin";
 
 class DataUriPlugin {
@@ -62,6 +35,7 @@ class DataUriPlugin {
 							resourceData.data.encodedContent = match[4] || "";
 						}
 					});
+
 				NormalModule.getCompilationHooks(compilation)
 					.readResourceForScheme.for("data")
 					.tap(PLUGIN_NAME, (resource) => decodeDataURI(resource));

package/lib/schemes/FileUriPlugin.js

@@ -40,8 +40,11 @@ class FileUriPlugin {
 					.for(undefined)
 					.tapAsync(PLUGIN_NAME, (loaderContext, callback) => {
 						const { resourcePath } = loaderContext;
-						loaderContext.addDependency(resourcePath);
-						loaderContext.fs.readFile(resourcePath, callback);
+						loaderContext.fs.readFile(resourcePath, (err, result) => {
+							if (err) return callback(err);
+							loaderContext.addDependency(resourcePath);
+							callback(null, result);
+						});
 					});
 			}
 		);

package/lib/schemes/HttpUriPlugin.js

@@ -1199,8 +1199,10 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 							getInfo(resource, (err, _result) => {
 								if (err) return callback(err);
 								const result = /** @type {Info} */ (_result);
-								/** @type {BuildInfo} */
-								(module.buildInfo).resourceIntegrity = result.entry.integrity;
+								if (module) {
+									/** @type {BuildInfo} */
+									(module.buildInfo).resourceIntegrity = result.entry.integrity;
+								}
 								callback(null, result.content);
 							})
 						);

package/lib/schemes/VirtualUrlPlugin.js

@@ -11,9 +11,6 @@ const { parseResourceWithoutFragment } = require("../util/identifier");
 
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../NormalModule")} NormalModule */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").ValueCacheVersions} ValueCacheVersions */
-/** @typedef {string | Set<string>} ValueCacheVersion */
 
 /**
  * @template T
@@ -23,18 +20,21 @@ const { parseResourceWithoutFragment } = require("../util/identifier");
 const PLUGIN_NAME = "VirtualUrlPlugin";
 const DEFAULT_SCHEME = "virtual";
 
+/** @typedef {(loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string | Buffer> | string | Buffer} SourceFn */
+/** @typedef {() => string} VersionFn */
+
 /**
  * @typedef {object} VirtualModuleConfig
- * @property {string=} type - The module type
- * @property {(loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string> | string} source - The source function
- * @property {(() => string) | true | string=} version - Optional version function or value
+ * @property {string=} type the module type
+ * @property {SourceFn} source the source function
+ * @property {VersionFn | true | string=} version optional version function or value
  */
 
 /**
- * @typedef {string | ((loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string> | string) | VirtualModuleConfig} VirtualModuleInput
+ * @typedef {string | SourceFn | VirtualModuleConfig} VirtualModuleInput
  */
 
-/** @typedef {{[key: string]: VirtualModuleInput}} VirtualModules */
+/** @typedef {{ [key: string]: VirtualModuleInput }} VirtualModules */
 
 /**
  * Normalizes a virtual module definition into a standard format
@@ -62,13 +62,13 @@ function normalizeModule(virtualConfig) {
  * Normalizes all virtual modules with the given scheme
  * @param {VirtualModules} virtualConfigs The virtual modules to normalize
  * @param {string} scheme The URL scheme to use
- * @returns {{[key: string]: VirtualModuleConfig}} The normalized virtual modules
+ * @returns {{ [key: string]: VirtualModuleConfig }} The normalized virtual modules
  */
 function normalizeModules(virtualConfigs, scheme) {
 	return Object.keys(virtualConfigs).reduce((pre, id) => {
 		pre[toVid(id, scheme)] = normalizeModule(virtualConfigs[id]);
 		return pre;
-	}, /** @type {{[key: string]: VirtualModuleConfig}} */ ({}));
+	}, /** @type {{ [key: string]: VirtualModuleConfig }} */ ({}));
 }
 
 /**
@@ -207,7 +207,7 @@ class VirtualUrlPlugin {
 
 	/**
 	 * Get the cache version for a given version value
-	 * @param {(() => string) | true | string} version The version value or function
+	 * @param {VersionFn | true | string} version The version value or function
 	 * @returns {string | undefined} The cache version
 	 */
 	getCacheVersion(version) {

package/lib/serialization/NullPrototypeObjectSerializer.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {string[]} Keys */
+
 class NullPrototypeObjectSerializer {
 	/**
 	 * @template {object} T
@@ -14,7 +16,7 @@ class NullPrototypeObjectSerializer {
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(obj, context) {
-		/** @type {string[]} */
+		/** @type {Keys} */
 		const keys = Object.keys(obj);
 		for (const key of keys) {
 			context.write(key);
@@ -33,9 +35,9 @@ class NullPrototypeObjectSerializer {
 	deserialize(context) {
 		/** @type {T} */
 		const obj = Object.create(null);
-		/** @type {string[]} */
+		/** @type {Keys} */
 		const keys = [];
-		/** @type {string | null} */
+		/** @type {Keys[number] | null} */
 		let key = context.read();
 		while (key !== null) {
 			keys.push(key);

package/lib/serialization/ObjectMiddleware.js

@@ -56,29 +56,29 @@ Technically any value can be used.
  * @property {number} objectTypeLookupSize
  * @property {number} currentPosTypeLookup
  */
-/** @typedef {TODO} Value */
+
 /** @typedef {EXPECTED_OBJECT | string} ReferenceableItem */
 
 /**
  * @typedef {object} ObjectSerializerContext
- * @property {(value: Value) => void} write
+ * @property {(value: EXPECTED_ANY) => void} write
  * @property {(value: ReferenceableItem) => void} setCircularReference
  * @property {() => ObjectSerializerSnapshot} snapshot
  * @property {(snapshot: ObjectSerializerSnapshot) => void} rollback
- * @property {((item: Value | (() => Value)) => void)=} writeLazy
- * @property {((item: (Value | (() => Value)), obj: LazyOptions | undefined) => import("./SerializerMiddleware").LazyFunction<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY, LazyOptions>)=} writeSeparate
+ * @property {((item: EXPECTED_ANY | (() => EXPECTED_ANY)) => void)=} writeLazy
+ * @property {((item: (EXPECTED_ANY | (() => EXPECTED_ANY)), obj: LazyOptions | undefined) => import("./SerializerMiddleware").LazyFunction<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY, LazyOptions>)=} writeSeparate
  */
 
 /**
  * @typedef {object} ObjectDeserializerContext
- * @property {() => Value} read
+ * @property {() => EXPECTED_ANY} read
  * @property {(value: ReferenceableItem) => void} setCircularReference
  */
 
 /**
  * @typedef {object} ObjectSerializer
- * @property {(value: Value, context: ObjectSerializerContext) => void} serialize
- * @property {(context: ObjectDeserializerContext) => Value} deserialize
+ * @property {(value: EXPECTED_ANY, context: ObjectSerializerContext) => void} serialize
+ * @property {(context: ObjectDeserializerContext) => EXPECTED_ANY} deserialize
  */
 
 /**
@@ -130,7 +130,7 @@ const CURRENT_VERSION = 2;
 /** @typedef {{ request?: string, name?: string | number | null, serializer?: ObjectSerializer }} SerializerConfig */
 /** @typedef {{ request?: string, name?: string | number | null, serializer: ObjectSerializer }} SerializerConfigWithSerializer */
 
-/** @type {Map<Constructor, SerializerConfig>} */
+/** @type {Map<Constructor | null, SerializerConfig>} */
 const serializers = new Map();
 /** @type {Map<string | number, ObjectSerializer>} */
 const serializerInversed = new Map();
@@ -140,6 +140,7 @@ const loadedRequests = new Set();
 
 const NOT_SERIALIZABLE = {};
 
+/** @type {Map<Constructor | null, ObjectSerializer>} */
 const jsTypes = new Map();
 
 jsTypes.set(Object, new PlainObjectSerializer());
@@ -335,7 +336,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
-		/** @type {Value[]} */
+		/** @type {PrimitiveSerializableType[]} */
 		let result = [CURRENT_VERSION];
 		let currentPos = 0;
 		/** @type {Map<ReferenceableItem, number>} */
@@ -412,7 +413,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let objectTypeLookup = new Map();
 		const cycleStack = new Set();
 		/**
-		 * @param {Value} item item to stack
+		 * @param {ComplexSerializableType} item item to stack
 		 * @returns {string} stack
 		 */
 		const stackToString = (item) => {
@@ -511,7 +512,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		this.extendContext(ctx);
 		/**
-		 * @param {Value} item item to serialize
+		 * @param {ComplexSerializableType} item item to serialize
 		 */
 		const process = (item) => {
 			if (Buffer.isBuffer(item)) {
@@ -533,7 +534,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				}
 				addReferenceable(item);
 
-				result.push(item);
+				result.push(/** @type {Buffer} */ (item));
 			} else if (item === ESCAPE) {
 				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
 			} else if (
@@ -553,8 +554,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 					);
 				}
 
-				const { request, name, serializer } =
-					ObjectMiddleware.getSerializerFor(item);
+				const { request, name, serializer } = ObjectMiddleware.getSerializerFor(
+					/** @type {Constructor} */
+					(item)
+				);
 				const key = `${request}/${name}`;
 				const lastIndex = objectTypeLookup.get(key);
 
@@ -616,9 +619,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 				} else if (SerializerMiddleware.isLazy(item, this)) {
 					throw new Error("Not implemented");
 				} else {
-					const data = SerializerMiddleware.serializeLazy(item, (data) =>
-						this.serialize([data], context)
-					);
+					const data =
+						/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
+						(
+							SerializerMiddleware.serializeLazy(item, (data) =>
+								this.serialize([data], context)
+							)
+						);
 					SerializerMiddleware.setLazySerializedValue(item, data);
 					result.push(data);
 				}
@@ -677,7 +684,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		/** @type {ReferenceableItem[]} */
 		let referenceable = [];
 		/**
-		 * @param {Value} item referenceable item
+		 * @param {ReferenceableItem} item referenceable item
 		 */
 		const addReferenceable = (item) => {
 			referenceable.push(item);
@@ -686,6 +693,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let currentPosTypeLookup = 0;
 		/** @type {ObjectSerializer[]} */
 		let objectTypeLookup = [];
+		/** @type {ComplexSerializableType[]} */
 		let result = [];
 		/** @type {ObjectDeserializerContext} */
 		let ctx = {
@@ -698,6 +706,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			...context
 		};
 		this.extendContext(ctx);
+		/**
+		 * @returns {ComplexSerializableType} deserialize value
+		 */
 		const decodeValue = () => {
 			const item = read();
 
@@ -789,7 +800,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 						const name = !serializerEntry
 							? "unknown"
 							: !serializerEntry[1].request
-								? serializerEntry[0].name
+								? /** @type {Constructor[]} */ (serializerEntry)[0].name
 								: serializerEntry[1].name
 									? `${serializerEntry[1].request} ${serializerEntry[1].name}`
 									: serializerEntry[1].request;

package/lib/serialization/SerializerMiddleware.js

@@ -96,7 +96,6 @@ class SerializerMiddleware {
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
 	 * @template {Record<string, EXPECTED_ANY>} TLazyOptions
-	 * @template TLazySerializedValue
 	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
 	 * @returns {LazyOptions | undefined} options
 	 */
@@ -123,7 +122,7 @@ class SerializerMiddleware {
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
 	 * @template {LazyOptions} TLazyOptions
-	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, LazyTarget, LazyOptions>} fn lazy function
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
 	 * @param {TLazyOutputValue} value serialized value
 	 * @returns {void}
 	 */
@@ -168,7 +167,6 @@ class SerializerMiddleware {
 	/**
 	 * @template TLazyInputValue SerializedValue
 	 * @template TLazyOutputValue DeserializedValue
-	 * @template SerializedValue
 	 * @template {LazyTarget} TLazyTarget
 	 * @template {LazyOptions | undefined} TLazyOptions
 	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} lazy lazy function

package/lib/serialization/types.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @typedef {undefined | null | number | string | boolean | Buffer | EXPECTED_OBJECT | (() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
+/** @typedef {undefined | null | number | bigint | string | boolean | Buffer | EXPECTED_OBJECT | (() => ComplexSerializableType[] | Promise<ComplexSerializableType[]>)} ComplexSerializableType */
 
 /** @typedef {undefined | null | number | bigint | string | boolean | Buffer | (() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>)} PrimitiveSerializableType */
 

package/lib/sharing/ConsumeSharedModule.js

@@ -17,21 +17,19 @@ const makeSerializable = require("../util/makeSerializable");
 const { rangeToString, stringifyHoley } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
@@ -104,7 +102,7 @@ class ConsumeSharedModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		const { shareKey, shareScope, import: request } = this.options;

package/lib/sharing/ConsumeSharedPlugin.js

@@ -23,8 +23,8 @@ const {
 	isRequiredVersion
 } = require("./utils");
 
+/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
 /** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
 /** @typedef {import("../util/semver").SemVerRange} SemVerRange */
@@ -168,12 +168,10 @@ class ConsumeSharedPlugin {
 									resolve();
 									return;
 								}
+								/** @typedef {ResolveContext} */
 								const resolveContext = {
-									/** @type {LazySet<string>} */
 									fileDependencies: new LazySet(),
-									/** @type {LazySet<string>} */
 									contextDependencies: new LazySet(),
-									/** @type {LazySet<string>} */
 									missingDependencies: new LazySet()
 								};
 								resolver.resolve(

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -23,7 +23,7 @@ const {
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
-/** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 
 class ConsumeSharedRuntimeModule extends RuntimeModule {
 	/**
@@ -40,17 +40,20 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
-		const { runtimeTemplate, codeGenerationResults } = compilation;
-		/** @type {Record<ChunkId, (string | number)[]>} */
+		const codeGenerationResults =
+			/** @type {CodeGenerationResults} */
+			(compilation.codeGenerationResults);
+		const { runtimeTemplate } = compilation;
+		/** @type {Record<ChunkId, ModuleId[]>} */
 		const chunkToModuleMapping = {};
-		/** @type {Map<string | number, Source>} */
+		/** @type {Map<ModuleId, Source>} */
 		const moduleIdToSourceMapping = new Map();
-		/** @type {(string | number)[]} */
+		/** @type {ModuleId[]} */
 		const initialConsumes = [];
 		/**
 		 * @param {Iterable<Module>} modules modules
 		 * @param {Chunk} chunk the chunk
-		 * @param {(string | number)[]} list list of ids
+		 * @param {ModuleId[]} list list of ids
 		 */
 		const addModules = (modules, chunk, list) => {
 			for (const m of modules) {

package/lib/sharing/ProvideSharedModule.js

@@ -13,24 +13,20 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 
-/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
+/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module").BuildCallback} BuildCallback */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
+/** @typedef {import("../Module").LibIdent} LibIdent */
 /** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
 /** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../WebpackError")} WebpackError */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
 class ProvideSharedModule extends Module {
@@ -69,7 +65,7 @@ class ProvideSharedModule extends Module {
 
 	/**
 	 * @param {LibIdentOptions} options options
-	 * @returns {string | null} an identifier for library inclusion
+	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
 		return `${this.layer ? `(${this.layer})/` : ""}webpack/sharing/provide/${

package/lib/sharing/SharePlugin.js

@@ -10,9 +10,7 @@ const ConsumeSharedPlugin = require("./ConsumeSharedPlugin");
 const ProvideSharedPlugin = require("./ProvideSharedPlugin");
 const { isRequiredVersion } = require("./utils");
 
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
 /** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumesConfig} ConsumesConfig */
-/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
 /** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvidesConfig} ProvidesConfig */
 /** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharePluginOptions} SharePluginOptions */
 /** @typedef {import("../../declarations/plugins/sharing/SharePlugin").SharedConfig} SharedConfig */

package/lib/sharing/ShareRuntimeModule.js

@@ -16,6 +16,7 @@ const {
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
 
 class ShareRuntimeModule extends RuntimeModule {
 	constructor() {
@@ -29,9 +30,11 @@ class ShareRuntimeModule extends RuntimeModule {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const {
 			runtimeTemplate,
-			codeGenerationResults,
 			outputOptions: { uniqueName, ignoreBrowserWarnings }
 		} = compilation;
+		const codeGenerationResults =
+			/** @type {CodeGenerationResults} */
+			(compilation.codeGenerationResults);
 		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		/** @type {Map<string, Map<number, Set<string>>>} */
 		const initCodePerScope = new Map();

package/lib/sharing/resolveMatchedConfigs.js

@@ -8,6 +8,7 @@
 const ModuleNotFoundError = require("../ModuleNotFoundError");
 const LazySet = require("../util/LazySet");
 
+/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
 
@@ -35,12 +36,10 @@ module.exports.resolveMatchedConfigs = (compilation, configs) => {
 	const unresolved = new Map();
 	/** @type {Map<string, T>} */
 	const prefixed = new Map();
+	/** @type {ResolveContext} */
 	const resolveContext = {
-		/** @type {LazySet<string>} */
 		fileDependencies: new LazySet(),
-		/** @type {LazySet<string>} */
 		contextDependencies: new LazySet(),
-		/** @type {LazySet<string>} */
 		missingDependencies: new LazySet()
 	};
 	const resolver = compilation.resolverFactory.get("normal", RESOLVE_OPTIONS);
@@ -84,9 +83,18 @@ module.exports.resolveMatchedConfigs = (compilation, configs) => {
 			}
 		})
 	).then(() => {
-		compilation.contextDependencies.addAll(resolveContext.contextDependencies);
-		compilation.fileDependencies.addAll(resolveContext.fileDependencies);
-		compilation.missingDependencies.addAll(resolveContext.missingDependencies);
+		compilation.contextDependencies.addAll(
+			/** @type {LazySet<string>} */
+			(resolveContext.contextDependencies)
+		);
+		compilation.fileDependencies.addAll(
+			/** @type {LazySet<string>} */
+			(resolveContext.fileDependencies)
+		);
+		compilation.missingDependencies.addAll(
+			/** @type {LazySet<string>} */
+			(resolveContext.missingDependencies)
+		);
 		return { resolved, unresolved, prefixed };
 	});
 };