@depup/webpack 5.109.0-depup.0 → 5.110.1-depup.0

package/lib/serialization/ObjectMiddleware.js

@@ -17,11 +17,15 @@ const RegExpObjectSerializer = require("./RegExpObjectSerializer");
 const SerializerMiddleware = require("./SerializerMiddleware");
 const SetObjectSerializer = require("./SetObjectSerializer");
 
-/** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
-/** @typedef {import("./SerializerMiddleware").LazyOptions} LazyOptions */
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
-/** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
+/** @import { Logger } from "../logging/Logger" */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { LazyOptions } from "./SerializerMiddleware" */
+/**
+ * @import {
+ * 	ComplexSerializableType,
+ * 	PrimitiveSerializableType
+ * } from "./types"
+ */
 
 /** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
 
@@ -457,7 +461,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 			return buf;
 		};
 		let currentPosTypeLookup = 0;
-		/** @type {Map<ComplexSerializableType, number>} */
+		/** @type {Map<SerializerConfigWithSerializer, number>} */
 		let objectTypeLookup = new Map();
 		/** @type {Set<ComplexSerializableType>} */
 		const cycleStack = new Set();
@@ -569,140 +573,160 @@ class ObjectMiddleware extends SerializerMiddleware {
 			...context
 		};
 		this.extendContext(ctx);
+		// Dispatched on `typeof` first: two thirds of the items are numbers,
+		// booleans and `undefined`, and only 3% are buffers.
 		/**
 		 * Processes the provided item.
 		 * @param {ComplexSerializableType} item item to serialize
 		 */
 		const process = (item) => {
-			if (Buffer.isBuffer(item)) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
+			switch (typeof item) {
+				case "number":
+				case "boolean":
+					result.push(item);
 					return;
-				}
-				const alreadyUsedBuffer = dedupeBuffer(item);
-				if (alreadyUsedBuffer !== item) {
-					const ref = referenceable.get(alreadyUsedBuffer);
-					if (ref !== undefined) {
-						referenceable.set(item, ref);
-						result.push(ESCAPE, ref - currentPos);
-						return;
+				case "string": {
+					if (item.length > 1) {
+						// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
+						// check if we can emit a reference
+						const ref = referenceable.get(item);
+						if (ref !== undefined) {
+							const offset = ref - currentPos;
+							if (
+								// One far ref → 5 bytes (`null` + offset), one near ref -> 2/3 bytes
+								offset >= -32768 ||
+								// long enough that the ref wins, keep it
+								item.length >= 4 ||
+								// multibyte → inline would be even bigger, keep it
+								Buffer.byteLength(item) !== item.length
+							) {
+								// A back-reference is `null` + the offset.
+								result.push(ESCAPE, offset);
+								return;
+							}
+						}
+						addReferenceable(item);
+					}
+
+					if (item.length > 102400 && context.logger) {
+						context.logger.warn(
+							`Serializing big strings (${Math.round(
+								item.length / 1024
+							)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
+						);
 					}
-					item = alreadyUsedBuffer;
-				}
-				addReferenceable(item);
 
-				result.push(/** @type {Buffer} */ (item));
-			} else if (item === ESCAPE) {
-				result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-			} else if (
-				typeof item === "object"
-				// We don't have to check for null as ESCAPE is null and this has been checked before
-			) {
-				// check if we can emit a reference
-				const ref = referenceable.get(item);
-				if (ref !== undefined) {
-					result.push(ESCAPE, ref - currentPos);
+					result.push(item);
 					return;
 				}
+				case "undefined":
+					result.push(ESCAPE, ESCAPE_UNDEFINED);
+					return;
+				case "object": {
+					// ESCAPE is null, so this covers null too
+					if (item === ESCAPE) {
+						result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
+						return;
+					}
 
-				if (cycleStack.has(item)) {
-					throw new Error(
-						"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
-					);
-				}
+					if (Buffer.isBuffer(item)) {
+						// check if we can emit a reference
+						const ref = referenceable.get(item);
+						if (ref !== undefined) {
+							result.push(ESCAPE, ref - currentPos);
+							return;
+						}
+						const alreadyUsedBuffer = dedupeBuffer(item);
+						if (alreadyUsedBuffer !== item) {
+							const ref = referenceable.get(alreadyUsedBuffer);
+							if (ref !== undefined) {
+								referenceable.set(item, ref);
+								result.push(ESCAPE, ref - currentPos);
+								return;
+							}
+							item = alreadyUsedBuffer;
+						}
+						addReferenceable(item);
 
-				const { request, name, serializer } = ObjectMiddleware.getSerializerFor(
-					/** @type {Constructor} */
-					(item)
-				);
-				const key = `${request}/${name}`;
-				const lastIndex = objectTypeLookup.get(key);
+						result.push(/** @type {Buffer} */ (item));
+						return;
+					}
 
-				if (lastIndex === undefined) {
-					objectTypeLookup.set(key, currentPosTypeLookup++);
+					// check if we can emit a reference
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						result.push(ESCAPE, ref - currentPos);
+						return;
+					}
 
-					result.push(ESCAPE, request, name);
-				} else {
-					result.push(ESCAPE, currentPosTypeLookup - lastIndex);
-				}
+					if (cycleStack.has(item)) {
+						throw new Error(
+							"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
+						);
+					}
 
-				cycleStack.add(item);
+					// Keyed by the registration itself: one per class, so it stands in for
+					// `${request}/${name}` without building that string per object.
+					const config = ObjectMiddleware.getSerializerFor(
+						/** @type {Constructor} */
+						(item)
+					);
+					const { request, name, serializer } = config;
+					const lastIndex = objectTypeLookup.get(config);
 
-				try {
-					serializer.serialize(item, ctx);
-				} finally {
-					cycleStack.delete(item);
-				}
+					if (lastIndex === undefined) {
+						objectTypeLookup.set(config, currentPosTypeLookup++);
 
-				result.push(ESCAPE, ESCAPE_END_OBJECT);
+						result.push(ESCAPE, request, name);
+					} else {
+						result.push(ESCAPE, currentPosTypeLookup - lastIndex);
+					}
 
-				addReferenceable(item);
-			} else if (typeof item === "string") {
-				if (item.length > 1) {
-					// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						const offset = ref - currentPos;
-						if (
-							// One far ref → 5 bytes (`null` + offset), one near ref -> 2/3 bytes
-							offset >= -32768 ||
-							// long enough that the ref wins, keep it
-							item.length >= 4 ||
-							// multibyte → inline would be even bigger, keep it
-							Buffer.byteLength(item) !== item.length
-						) {
-							// A back-reference is `null` + the offset.
-							result.push(ESCAPE, offset);
-							return;
-						}
+					cycleStack.add(item);
+
+					try {
+						serializer.serialize(item, ctx);
+					} finally {
+						cycleStack.delete(item);
 					}
-					addReferenceable(item);
-				}
 
-				if (item.length > 102400 && context.logger) {
-					context.logger.warn(
-						`Serializing big strings (${Math.round(
-							item.length / 1024
-						)}kiB) impacts deserialization performance (consider using Buffer instead and decode when needed)`
-					);
-				}
+					result.push(ESCAPE, ESCAPE_END_OBJECT);
 
-				result.push(item);
-			} else if (typeof item === "function") {
-				if (!SerializerMiddleware.isLazy(item)) {
-					throw new Error(`Unexpected function ${item}`);
+					addReferenceable(item);
+					return;
 				}
+				case "function": {
+					if (!SerializerMiddleware.isLazy(item)) {
+						throw new Error(`Unexpected function ${item}`);
+					}
 
-				/** @type {SerializedType | undefined} */
-				const serializedData =
-					SerializerMiddleware.getLazySerializedValue(item);
+					/** @type {SerializedType | undefined} */
+					const serializedData =
+						SerializerMiddleware.getLazySerializedValue(item);
 
-				if (serializedData !== undefined) {
-					if (typeof serializedData === "function") {
-						result.push(serializedData);
-					} else {
+					if (serializedData !== undefined) {
+						if (typeof serializedData === "function") {
+							result.push(serializedData);
+						} else {
+							throw new Error("Not implemented");
+						}
+					} else if (SerializerMiddleware.isLazy(item, this)) {
 						throw new Error("Not implemented");
+					} else {
+						const data =
+							/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
+							(
+								SerializerMiddleware.serializeLazy(item, (data) =>
+									this.serialize([data], context)
+								)
+							);
+						SerializerMiddleware.setLazySerializedValue(item, data);
+						result.push(data);
 					}
-				} else if (SerializerMiddleware.isLazy(item, this)) {
-					throw new Error("Not implemented");
-				} else {
-					const data =
-						/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
-						(
-							SerializerMiddleware.serializeLazy(item, (data) =>
-								this.serialize([data], context)
-							)
-						);
-					SerializerMiddleware.setLazySerializedValue(item, data);
-					result.push(data);
+					return;
 				}
-			} else if (item === undefined) {
-				result.push(ESCAPE, ESCAPE_UNDEFINED);
-			} else {
-				result.push(item);
+				default:
+					result.push(item);
 			}
 		};
 
@@ -933,5 +957,6 @@ class ObjectMiddleware extends SerializerMiddleware {
 	}
 }
 
+ObjectMiddleware.NOT_SERIALIZABLE = NOT_SERIALIZABLE;
+
 module.exports = ObjectMiddleware;
-module.exports.NOT_SERIALIZABLE = NOT_SERIALIZABLE;

package/lib/serialization/PlainObjectSerializer.js

@@ -3,32 +3,32 @@
 */
 
 "use strict";
+/** @import { ObjectDeserializerContext, ObjectSerializerContext } from "./ObjectMiddleware" */
 
-/** @typedef {EXPECTED_FUNCTION} CacheAssoc */
+/** @typedef {ObjectSerializerContext<EXPECTED_ANY>["write"]} CacheAssoc */
 
 /**
  * Defines the shared type used by this module.
- * @template T
- * @typedef {WeakMap<CacheAssoc, ObjectStructure<T>>}
+ * @type {WeakMap<CacheAssoc, ObjectStructure<PropertyKey>>}
  */
 const cache = new WeakMap();
 
 /**
  * Represents ObjectStructure.
- * @template T
+ * @template {PropertyKey} K
  */
 class ObjectStructure {
 	constructor() {
-		/** @type {undefined | keyof T[]} */
+		/** @type {undefined | K[]} */
 		this.keys = undefined;
-		/** @type {undefined | Map<keyof T, ObjectStructure<T>>} */
+		/** @type {undefined | Map<K, ObjectStructure<K>>} */
 		this.children = undefined;
 	}
 
 	/**
 	 * Returns keys.
-	 * @param {keyof T[]} keys keys
-	 * @returns {keyof T[]} keys
+	 * @param {K[]} keys keys
+	 * @returns {K[]} keys
 	 */
 	getKeys(keys) {
 		if (this.keys === undefined) this.keys = keys;
@@ -37,13 +37,14 @@ class ObjectStructure {
 
 	/**
 	 * Returns object structure.
-	 * @param {keyof T} key key
-	 * @returns {ObjectStructure<T>} object structure
+	 * @param {K} key key
+	 * @returns {ObjectStructure<K>} object structure
 	 */
 	key(key) {
 		if (this.children === undefined) this.children = new Map();
 		const child = this.children.get(key);
 		if (child !== undefined) return child;
+		/** @type {ObjectStructure<K>} */
 		const newChild = new ObjectStructure();
 		this.children.set(key, newChild);
 		return newChild;
@@ -52,13 +53,15 @@ class ObjectStructure {
 
 /**
  * Returns keys.
- * @template T
- * @param {(keyof T)[]} keys keys
+ * @template {PropertyKey} K
+ * @param {K[]} keys keys
  * @param {CacheAssoc} cacheAssoc cache assoc fn
- * @returns {(keyof T)[]} keys
+ * @returns {K[]} keys
  */
 const getCachedKeys = (keys, cacheAssoc) => {
-	let root = cache.get(cacheAssoc);
+	let root = /** @type {ObjectStructure<K> | undefined} */ (
+		cache.get(cacheAssoc)
+	);
 	if (root === undefined) {
 		root = new ObjectStructure();
 		cache.set(cacheAssoc, root);
@@ -75,7 +78,7 @@ class PlainObjectSerializer {
 	 * Serializes this instance into the provided serializer context.
 	 * @template {object} T
 	 * @param {T} obj plain object
-	 * @param {import("./ObjectMiddleware").ObjectSerializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
+	 * @param {ObjectSerializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
 	 */
 	serialize(obj, context) {
 		const keys = /** @type {(keyof T)[]} */ (Object.keys(obj));
@@ -103,7 +106,7 @@ class PlainObjectSerializer {
 	/**
 	 * Restores this instance from the provided deserializer context.
 	 * @template {object} T
-	 * @param {import("./ObjectMiddleware").ObjectDeserializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
+	 * @param {ObjectDeserializerContext<((keyof T)[] | keyof T | null | T[keyof T])[]>} context context
 	 * @returns {T} plain object
 	 */
 	deserialize(context) {

package/lib/sharing/ConsumeSharedModule.js

@@ -23,28 +23,36 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 /** @type {WeakMap<ModuleGraph, WeakMap<ConsumeSharedModule, Module | null>>} */
 const fallbackModuleCache = new WeakMap();
 
-/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @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").Sources} Sources */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../Module").ExportsType} ExportsType */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
+ * } from "../config/defaults"
+ */
+/** @import Compilation from "../Compilation" */
+/** @import { UpdateHashContext } from "../Dependency" */
+/**
+ * @import {
+ * 	BuildCallback,
+ * 	CodeGenerationContext,
+ * 	CodeGenerationResult,
+ * 	LibIdentOptions,
+ * 	LibIdent,
+ * 	NeedBuildCallback,
+ * 	NeedBuildContext,
+ * 	Sources,
+ * 	SourceTypes,
+ * 	ExportsType,
+ * 	BasicSourceTypes
+ * } from "../Module"
+ */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { ResolverWithOptions } from "../ResolverFactory" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ConsumeOptions]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ConsumeOptions]>} ObjectSerializerContext */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
-/** @typedef {import("../util/semver").SemVerRange} SemVerRange */
-/** @typedef {import("../Module").BasicSourceTypes} BasicSourceTypes */
+/** @import Hash from "../util/Hash" */
+/** @import { InputFileSystem } from "../util/fs" */
+/** @import { SemVerRange } from "../util/semver" */
 
 /**
  * Represents the consume shared module runtime component.
@@ -291,7 +299,8 @@ class ConsumeSharedModule extends Module {
 					block,
 					chunkGraph,
 					runtimeRequirements,
-					request: this.options.import
+					request: this.options.import,
+					originModule: this
 				});
 			}
 		}

package/lib/sharing/ConsumeSharedPlugin.js

@@ -7,9 +7,9 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const { parseOptions } = require("../container/options");
-const ModuleNotFoundError = require("../errors/ModuleNotFoundError");
 const WebpackError = require("../errors/WebpackError");
 const LazySet = require("../util/LazySet");
+const memoize = require("../util/memoize");
 const { parseRange } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
 const ConsumeSharedModule = require("./ConsumeSharedModule");
@@ -22,14 +22,22 @@ const {
 	isRequiredVersion
 } = require("./utils");
 
-/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
-/** @typedef {import("../../declarations/plugins/sharing/ConsumeSharedPlugin").ConsumeSharedPluginOptions} ConsumeSharedPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
-/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
-/** @typedef {import("../util/semver").SemVerRange} SemVerRange */
-/** @typedef {import("./ConsumeSharedModule").ConsumeOptions} ConsumeOptions */
-/** @typedef {import("./utils").DescriptionFile} DescriptionFile */
+const getModuleNotFoundError = memoize(() =>
+	require("../errors/ModuleNotFoundError")
+);
+
+/** @import { ResolveContext } from "enhanced-resolve" */
+/**
+ * @import {
+ * 	ConsumeSharedPluginOptions
+ * } from "../../declarations/plugins/sharing/ConsumeSharedPlugin"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import { FileSystemDependencies } from "../Compilation" */
+/** @import { ResolveOptionsWithDependencyType } from "../ResolverFactory" */
+/** @import { SemVerRange } from "../util/semver" */
+/** @import { ConsumeOptions } from "./ConsumeSharedModule" */
+/** @import { DescriptionFile } from "./utils" */
 
 /** @type {ResolveOptionsWithDependencyType} */
 const RESOLVE_OPTIONS = { dependencyType: "esm" };
@@ -206,7 +214,7 @@ class ConsumeSharedPlugin {
 										);
 										if (err) {
 											compilation.errors.push(
-												new ModuleNotFoundError(null, err, {
+												new (getModuleNotFoundError())(null, err, {
 													name: `resolving fallback for shared module ${request}`
 												})
 											);

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -16,15 +16,12 @@ const {
 	versionLtRuntimeCode
 } = require("../util/semver");
 
-/** @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("../CodeGenerationResults")} CodeGenerationResults */
+/** @import { Source } from "webpack-sources" */
+/** @import Chunk, { ChunkId } from "../Chunk" */
+/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import Module, { ReadOnlyRuntimeRequirements } from "../Module" */
+/** @import CodeGenerationResults from "../CodeGenerationResults" */
 
 class ConsumeSharedRuntimeModule extends RuntimeModule {
 	/**

package/lib/sharing/ProvideSharedModule.js

@@ -13,23 +13,31 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 
-/** @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").Sources} Sources */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
+ * } from "../config/defaults"
+ */
+/** @import Compilation from "../Compilation" */
+/**
+ * @import {
+ * 	BuildCallback,
+ * 	CodeGenerationContext,
+ * 	CodeGenerationResult,
+ * 	LibIdentOptions,
+ * 	LibIdent,
+ * 	NeedBuildCallback,
+ * 	NeedBuildContext,
+ * 	Sources,
+ * 	SourceTypes,
+ * 	CodeGenerationResultData
+ * } from "../Module"
+ */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { ResolverWithOptions } from "../ResolverFactory" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[string, string, string | false, string, boolean]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[string, string, string | false, string, boolean]>} ObjectSerializerContext */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/** @import { InputFileSystem } from "../util/fs" */
 
 class ProvideSharedModule extends Module {
 	/**
@@ -160,7 +168,8 @@ class ProvideSharedModule extends Module {
 						block: this.blocks[0],
 						chunkGraph,
 						request: this._request,
-						runtimeRequirements
+						runtimeRequirements,
+						originModule: this
 					})
 		}${this._eager ? ", 1" : ""});`;
 		/** @type {Sources} */

package/lib/sharing/ProvideSharedModuleFactory.js

@@ -8,9 +8,13 @@
 const ModuleFactory = require("../ModuleFactory");
 const ProvideSharedModule = require("./ProvideSharedModule");
 
-/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("./ProvideSharedDependency")} ProvideSharedDependency */
+/**
+ * @import {
+ * 	ModuleFactoryCallback,
+ * 	ModuleFactoryCreateData
+ * } from "../ModuleFactory"
+ */
+/** @import ProvideSharedDependency from "./ProvideSharedDependency" */
 
 class ProvideSharedModuleFactory extends ModuleFactory {
 	/**

package/lib/sharing/ProvideSharedPlugin.js

@@ -12,10 +12,14 @@ const ProvideForSharedDependency = require("./ProvideForSharedDependency");
 const ProvideSharedDependency = require("./ProvideSharedDependency");
 const ProvideSharedModuleFactory = require("./ProvideSharedModuleFactory");
 
-/** @typedef {import("../../declarations/plugins/sharing/ProvideSharedPlugin").ProvideSharedPluginOptions} ProvideSharedPluginOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../NormalModuleFactory").NormalModuleCreateData} NormalModuleCreateData */
+/**
+ * @import {
+ * 	ProvideSharedPluginOptions
+ * } from "../../declarations/plugins/sharing/ProvideSharedPlugin"
+ */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import { NormalModuleCreateData } from "../NormalModule" */
 
 /**
  * Defines the provide options type used by this module.