webpack 5.59.0 → 5.94.0

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -17,35 +17,45 @@ const {
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Module")} Module */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 /** @typedef {import("./ConsumeSharedModule")} ConsumeSharedModule */
 
 class ConsumeSharedRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 */
 	constructor(runtimeRequirements) {
 		super("consumes", RuntimeModule.STAGE_ATTACH);
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation, chunkGraph } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
 		const { runtimeTemplate, codeGenerationResults } = compilation;
+		/** @type {Record<ChunkId, (string | number)[]>} */
 		const chunkToModuleMapping = {};
 		/** @type {Map<string | number, Source>} */
 		const moduleIdToSourceMapping = new Map();
+		/** @type {(string | number)[]} */
 		const initialConsumes = [];
 		/**
-		 *
 		 * @param {Iterable<Module>} modules modules
 		 * @param {Chunk} chunk the chunk
 		 * @param {(string | number)[]} list list of ids
 		 */
 		const addModules = (modules, chunk, list) => {
 			for (const m of modules) {
-				const module = /** @type {ConsumeSharedModule} */ (m);
-				const id = chunkGraph.getModuleId(module);
+				const module = m;
+				const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
 				list.push(id);
 				moduleIdToSourceMapping.set(
 					id,
@@ -57,15 +67,21 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 				);
 			}
 		};
-		for (const chunk of this.chunk.getAllAsyncChunks()) {
+		for (const chunk of /** @type {Chunk} */ (this.chunk).getAllAsyncChunks()) {
 			const modules = chunkGraph.getChunkModulesIterableBySourceType(
 				chunk,
 				"consume-shared"
 			);
 			if (!modules) continue;
-			addModules(modules, chunk, (chunkToModuleMapping[chunk.id] = []));
+			addModules(
+				modules,
+				chunk,
+				(chunkToModuleMapping[/** @type {ChunkId} */ (chunk.id)] = [])
+			);
 		}
-		for (const chunk of this.chunk.getAllInitialChunks()) {
+		for (const chunk of /** @type {Chunk} */ (
+			this.chunk
+		).getAllInitialChunks()) {
 			const modules = chunkGraph.getChunkModulesIterableBySourceType(
 				chunk,
 				"consume-shared"
@@ -79,57 +95,39 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 			versionLtRuntimeCode(runtimeTemplate),
 			rangeToStringRuntimeCode(runtimeTemplate),
 			satisfyRuntimeCode(runtimeTemplate),
-			`var ensureExistence = ${runtimeTemplate.basicFunction("scopeName, key", [
-				`var scope = ${RuntimeGlobals.shareScopeMap}[scopeName];`,
-				`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) throw new Error("Shared module " + key + " doesn't exist in shared scope " + scopeName);`,
-				"return scope;"
+			`var exists = ${runtimeTemplate.basicFunction("scope, key", [
+				`return scope && ${RuntimeGlobals.hasOwnProperty}(scope, key);`
+			])}`,
+			`var get = ${runtimeTemplate.basicFunction("entry", [
+				"entry.loaded = 1;",
+				"return entry.get()"
 			])};`,
-			`var findVersion = ${runtimeTemplate.basicFunction("scope, key", [
-				"var versions = scope[key];",
-				`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
-					"a, b",
-					["return !a || versionLt(a, b) ? b : a;"]
-				)}, 0);`,
-				"return key && versions[key]"
+			`var eagerOnly = ${runtimeTemplate.basicFunction("versions", [
+				`return Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+					"filtered, version",
+					Template.indent([
+						"if (versions[version].eager) {",
+						Template.indent(["filtered[version] = versions[version];"]),
+						"}",
+						"return filtered;"
+					])
+				)}, {});`
 			])};`,
-			`var findSingletonVersionKey = ${runtimeTemplate.basicFunction(
-				"scope, key",
+			`var findLatestVersion = ${runtimeTemplate.basicFunction(
+				"scope, key, eager",
 				[
-					"var versions = scope[key];",
-					`return Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+					"var versions = eager ? eagerOnly(scope[key]) : scope[key];",
+					`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
 						"a, b",
-						["return !a || (!versions[a].loaded && versionLt(a, b)) ? b : a;"]
-					)}, 0);`
-				]
-			)};`,
-			`var getInvalidSingletonVersionMessage = ${runtimeTemplate.basicFunction(
-				"key, version, requiredVersion",
-				[
-					`return "Unsatisfied version " + version + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"`
-				]
-			)};`,
-			`var getSingletonVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var version = findSingletonVersionKey(scope, key);",
-					"if (!satisfy(requiredVersion, version)) " +
-						'typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(key, version, requiredVersion));',
-					"return get(scope[key][version]);"
-				]
-			)};`,
-			`var getStrictSingletonVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
-				[
-					"var version = findSingletonVersionKey(scope, key);",
-					"if (!satisfy(requiredVersion, version)) " +
-						"throw new Error(getInvalidSingletonVersionMessage(key, version, requiredVersion));",
-					"return get(scope[key][version]);"
+						["return !a || versionLt(a, b) ? b : a;"]
+					)}, 0);`,
+					"return key && versions[key];"
 				]
 			)};`,
-			`var findValidVersion = ${runtimeTemplate.basicFunction(
-				"scope, key, requiredVersion",
+			`var findSatisfyingVersion = ${runtimeTemplate.basicFunction(
+				"scope, key, requiredVersion, eager",
 				[
-					"var versions = scope[key];",
+					"var versions = eager ? eagerOnly(scope[key]) : scope[key];",
 					`var key = Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
 						"a, b",
 						[
@@ -140,115 +138,127 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 					"return key && versions[key]"
 				]
 			)};`,
-			`var getInvalidVersionMessage = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
+			`var findSingletonVersionKey = ${runtimeTemplate.basicFunction(
+				"scope, key, eager",
 				[
-					"var versions = scope[key];",
-					'return "No satisfying version (" + rangeToString(requiredVersion) + ") of shared module " + key + " found in shared scope " + scopeName + ".\\n" +',
-					`\t"Available versions: " + Object.keys(versions).map(${runtimeTemplate.basicFunction(
-						"key",
-						['return key + " from " + versions[key].from;']
-					)}).join(", ");`
+					"var versions = eager ? eagerOnly(scope[key]) : scope[key];",
+					`return Object.keys(versions).reduce(${runtimeTemplate.basicFunction(
+						"a, b",
+						["return !a || (!versions[a].loaded && versionLt(a, b)) ? b : a;"]
+					)}, 0);`
 				]
 			)};`,
-			`var getValidVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
+			`var getInvalidSingletonVersionMessage = ${runtimeTemplate.basicFunction(
+				"scope, key, version, requiredVersion",
 				[
-					"var entry = findValidVersion(scope, key, requiredVersion);",
-					"if(entry) return get(entry);",
-					"throw new Error(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));"
+					'return "Unsatisfied version " + version + " from " + (version && scope[key][version].from) + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"'
 				]
 			)};`,
-			`var warnInvalidVersion = ${runtimeTemplate.basicFunction(
-				"scope, scopeName, key, requiredVersion",
+			`var getInvalidVersionMessage = ${runtimeTemplate.basicFunction(
+				"scope, scopeName, key, requiredVersion, eager",
 				[
-					'typeof console !== "undefined" && console.warn && console.warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));'
+					"var versions = scope[key];",
+					'return "No satisfying version (" + rangeToString(requiredVersion) + ")" + (eager ? " for eager consumption" : "") + " of shared module " + key + " found in shared scope " + scopeName + ".\\n" +',
+					`\t"Available versions: " + Object.keys(versions).map(${runtimeTemplate.basicFunction(
+						"key",
+						['return key + " from " + versions[key].from;']
+					)}).join(", ");`
 				]
 			)};`,
-			`var get = ${runtimeTemplate.basicFunction("entry", [
-				"entry.loaded = 1;",
-				"return entry.get()"
-			])};`,
+			`var fail = ${runtimeTemplate.basicFunction("msg", [
+				"throw new Error(msg);"
+			])}`,
+			`var failAsNotExist = ${runtimeTemplate.basicFunction("scopeName, key", [
+				'return fail("Shared module " + key + " doesn\'t exist in shared scope " + scopeName);'
+			])}`,
+			`var warn = /*#__PURE__*/ ${
+				compilation.outputOptions.ignoreBrowserWarnings
+					? runtimeTemplate.basicFunction("", "")
+					: runtimeTemplate.basicFunction("msg", [
+							'if (typeof console !== "undefined" && console.warn) console.warn(msg);'
+						])
+			};`,
 			`var init = ${runtimeTemplate.returningFunction(
 				Template.asString([
-					"function(scopeName, a, b, c) {",
+					"function(scopeName, key, eager, c, d) {",
 					Template.indent([
 						`var promise = ${RuntimeGlobals.initializeSharing}(scopeName);`,
-						`if (promise && promise.then) return promise.then(fn.bind(fn, scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c));`,
-						`return fn(scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], a, b, c);`
+						// if we require eager shared, we expect it to be already loaded before it requested, no need to wait the whole scope loaded.
+						"if (promise && promise.then && !eager) { ",
+						Template.indent([
+							`return promise.then(fn.bind(fn, scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], key, false, c, d));`
+						]),
+						"}",
+						`return fn(scopeName, ${RuntimeGlobals.shareScopeMap}[scopeName], key, eager, c, d);`
 					]),
 					"}"
 				]),
 				"fn"
 			)};`,
 			"",
+			`var useFallback = ${runtimeTemplate.basicFunction(
+				"scopeName, key, fallback",
+				["return fallback ? fallback() : failAsNotExist(scopeName, key);"]
+			)}`,
 			`var load = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key",
-				[
-					"ensureExistence(scopeName, key);",
-					"return get(findVersion(scope, key));"
-				]
-			)});`,
-			`var loadFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, fallback",
+				"scopeName, scope, key, eager, fallback",
 				[
-					`return scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) ? get(findVersion(scope, key)) : fallback();`
+					"if (!exists(scope, key)) return useFallback(scopeName, key, fallback);",
+					"return get(findLatestVersion(scope, key, eager));"
 				]
 			)});`,
-			`var loadVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
+			`var loadVersion = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, eager, requiredVersion, fallback",
 				[
-					"ensureExistence(scopeName, key);",
-					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
+					"if (!exists(scope, key)) return useFallback(scopeName, key, fallback);",
+					"var satisfyingVersion = findSatisfyingVersion(scope, key, requiredVersion, eager);",
+					"if (satisfyingVersion) return get(satisfyingVersion);",
+					"warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion, eager))",
+					"return get(findLatestVersion(scope, key, eager));"
 				]
 			)});`,
-			`var loadSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
+			`var loadStrictVersion = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, eager, requiredVersion, fallback",
 				[
-					"ensureExistence(scopeName, key);",
-					"return getSingletonVersion(scope, scopeName, key, version);"
+					"if (!exists(scope, key)) return useFallback(scopeName, key, fallback);",
+					"var satisfyingVersion = findSatisfyingVersion(scope, key, requiredVersion, eager);",
+					"if (satisfyingVersion) return get(satisfyingVersion);",
+					"if (fallback) return fallback();",
+					"fail(getInvalidVersionMessage(scope, scopeName, key, requiredVersion, eager));"
 				]
 			)});`,
-			`var loadStrictVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
+			`var loadSingleton = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, eager, fallback",
 				[
-					"ensureExistence(scopeName, key);",
-					"return getValidVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadStrictSingletonVersionCheck = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version",
-				[
-					"ensureExistence(scopeName, key);",
-					"return getStrictSingletonVersion(scope, scopeName, key, version);"
-				]
-			)});`,
-			`var loadVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));"
-				]
-			)});`,
-			`var loadSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
-				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return getSingletonVersion(scope, scopeName, key, version);"
+					"if (!exists(scope, key)) return useFallback(scopeName, key, fallback);",
+					"var version = findSingletonVersionKey(scope, key, eager);",
+					"return get(scope[key][version]);"
 				]
 			)});`,
-			`var loadStrictVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
+			`var loadSingletonVersion = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, eager, requiredVersion, fallback",
 				[
-					`var entry = scope && ${RuntimeGlobals.hasOwnProperty}(scope, key) && findValidVersion(scope, key, version);`,
-					`return entry ? get(entry) : fallback();`
+					"if (!exists(scope, key)) return useFallback(scopeName, key, fallback);",
+					"var version = findSingletonVersionKey(scope, key, eager);",
+					"if (!satisfy(requiredVersion, version)) {",
+					Template.indent([
+						"warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));"
+					]),
+					"}",
+					"return get(scope[key][version]);"
 				]
 			)});`,
-			`var loadStrictSingletonVersionCheckFallback = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
-				"scopeName, scope, key, version, fallback",
+			`var loadStrictSingletonVersion = /*#__PURE__*/ init(${runtimeTemplate.basicFunction(
+				"scopeName, scope, key, eager, requiredVersion, fallback",
 				[
-					`if(!scope || !${RuntimeGlobals.hasOwnProperty}(scope, key)) return fallback();`,
-					"return getStrictSingletonVersion(scope, scopeName, key, version);"
+					"if (!exists(scope, key)) return useFallback(scopeName, key, fallback);",
+					"var version = findSingletonVersionKey(scope, key, eager);",
+					"if (!satisfy(requiredVersion, version)) {",
+					Template.indent([
+						"fail(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));"
+					]),
+					"}",
+					"return get(scope[key][version]);"
 				]
 			)});`,
 			"var installedModules = {};",
@@ -273,10 +283,10 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 								`delete ${RuntimeGlobals.moduleCache}[id];`,
 								"var factory = moduleToHandlerMapping[id]();",
 								'if(typeof factory !== "function") throw new Error("Shared module is not available for eager consumption: " + id);',
-								`module.exports = factory();`
+								"module.exports = factory();"
 							])}`
 						])});`
-				  ])
+					])
 				: "// no consumes in initial chunks",
 			this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
 				? Template.asString([
@@ -285,6 +295,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 							null,
 							"\t"
 						)};`,
+						"var startedInstallModules = {};",
 						`${
 							RuntimeGlobals.ensureChunkHandlers
 						}.consumes = ${runtimeTemplate.basicFunction("chunkId, promises", [
@@ -294,6 +305,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 									"id",
 									[
 										`if(${RuntimeGlobals.hasOwnProperty}(installedModules, id)) return promises.push(installedModules[id]);`,
+										"if(!startedInstallModules[id]) {",
 										`var onFactory = ${runtimeTemplate.basicFunction(
 											"factory",
 											[
@@ -306,6 +318,7 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 												])}`
 											]
 										)};`,
+										"startedInstallModules[id] = true;",
 										`var onError = ${runtimeTemplate.basicFunction("error", [
 											"delete installedModules[id];",
 											`${
@@ -320,17 +333,18 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 											"var promise = moduleToHandlerMapping[id]();",
 											"if(promise.then) {",
 											Template.indent(
-												`promises.push(installedModules[id] = promise.then(onFactory).catch(onError));`
+												"promises.push(installedModules[id] = promise.then(onFactory)['catch'](onError));"
 											),
 											"} else onFactory(promise);"
 										]),
-										"} catch(e) { onError(e); }"
+										"} catch(e) { onError(e); }",
+										"}"
 									]
 								)});`
 							]),
 							"}"
 						])}`
-				  ])
+					])
 				: "// no chunk loading of consumes"
 		]);
 	}

package/lib/sharing/ProvideForSharedDependency.js

@@ -10,7 +10,6 @@ const makeSerializable = require("../util/makeSerializable");
 
 class ProvideForSharedDependency extends ModuleDependency {
 	/**
-	 *
 	 * @param {string} request request string
 	 */
 	constructor(request) {

package/lib/sharing/ProvideSharedDependency.js

@@ -8,7 +8,17 @@
 const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
 class ProvideSharedDependency extends Dependency {
+	/**
+	 * @param {string} shareScope share scope
+	 * @param {string} name module name
+	 * @param {string | false} version version
+	 * @param {string} request request
+	 * @param {boolean} eager true, if this is an eager dependency
+	 */
 	constructor(shareScope, name, version, request, eager) {
 		super();
 		this.shareScope = shareScope;
@@ -31,6 +41,9 @@ class ProvideSharedDependency extends Dependency {
 		} @ ${this.version}${this.eager ? " (eager)" : ""}`;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		context.write(this.shareScope);
 		context.write(this.name);
@@ -40,6 +53,10 @@ class ProvideSharedDependency extends Dependency {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ProvideSharedDependency} deserialize fallback dependency
+	 */
 	static deserialize(context) {
 		const { read } = context;
 		const obj = new ProvideSharedDependency(

package/lib/sharing/ProvideSharedModule.js

@@ -7,6 +7,7 @@
 
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
+const { WEBPACK_MODULE_TYPE_PROVIDE } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
@@ -20,9 +21,12 @@ const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
 /** @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 */
 
@@ -37,7 +41,7 @@ class ProvideSharedModule extends Module {
 	 * @param {boolean} eager include the module in sync way
 	 */
 	constructor(shareScope, name, version, request, eager) {
-		super("provide-module");
+		super(WEBPACK_MODULE_TYPE_PROVIDE);
 		this._shareScope = shareScope;
 		this._name = name;
 		this._version = version;
@@ -67,12 +71,14 @@ class ProvideSharedModule extends Module {
 	 * @returns {string | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
-		return `webpack/sharing/provide/${this._shareScope}/${this._name}`;
+		return `${this.layer ? `(${this.layer})/` : ""}webpack/sharing/provide/${
+			this._shareScope
+		}/${this._name}`;
 	}
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -115,7 +121,7 @@ class ProvideSharedModule extends Module {
 	}
 
 	/**
-	 * @returns {Set<string>} types available (do not mutate)
+	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
 		return TYPES;
@@ -136,13 +142,13 @@ class ProvideSharedModule extends Module {
 						chunkGraph,
 						request: this._request,
 						runtimeRequirements
-				  })
+					})
 				: runtimeTemplate.asyncModuleFactory({
 						block: this.blocks[0],
 						chunkGraph,
 						request: this._request,
 						runtimeRequirements
-				  })
+					})
 		}${this._eager ? ", 1" : ""});`;
 		const sources = new Map();
 		const data = new Map();
@@ -156,6 +162,9 @@ class ProvideSharedModule extends Module {
 		return { sources, data, runtimeRequirements };
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(context) {
 		const { write } = context;
 		write(this._shareScope);
@@ -166,6 +175,10 @@ class ProvideSharedModule extends Module {
 		super.serialize(context);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {ProvideSharedModule} deserialize fallback dependency
+	 */
 	static deserialize(context) {
 		const { read } = context;
 		const obj = new ProvideSharedModule(read(), read(), read(), read(), read());

package/lib/sharing/ProvideSharedModuleFactory.js

@@ -15,7 +15,7 @@ const ProvideSharedModule = require("./ProvideSharedModule");
 class ProvideSharedModuleFactory extends ModuleFactory {
 	/**
 	 * @param {ModuleFactoryCreateData} data data object
-	 * @param {function(Error=, ModuleFactoryResult=): void} callback callback
+	 * @param {function((Error | null)=, ModuleFactoryResult=): void} callback callback
 	 * @returns {void}
 	 */
 	create(data, callback) {