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

package/lib/schemes/HttpUriPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const EventEmitter = require("events");
+
 const { basename, extname } = require("path");
 const {
 	// eslint-disable-next-line n/no-unsupported-features/node-builtins
@@ -18,21 +19,29 @@ const createHash = require("../util/createHash");
 const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 
-/** @typedef {import("http").IncomingMessage} IncomingMessage */
-/** @typedef {import("http").OutgoingHttpHeaders} OutgoingHttpHeaders */
-/** @typedef {import("http").RequestOptions} RequestOptions */
-/** @typedef {import("net").Socket} Socket */
-/** @typedef {import("stream").Readable} Readable */
-/** @typedef {import("../../declarations/plugins/schemes/HttpUriPlugin").HttpUriPluginOptions} HttpUriPluginOptions */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../NormalModuleFactory").ResourceDataWithData} ResourceDataWithData */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
+const getHttps = memoize(() => require("https"));
 
 const getHttp = memoize(() => require("http"));
-const getHttps = memoize(() => require("https"));
+
+/**
+ * @import {
+ * 	IncomingMessage,
+ * 	OutgoingHttpHeaders,
+ * 	RequestOptions
+ * } from "http"
+ */
+/** @import { Socket } from "net" */
+/** @import { Readable } from "stream" */
+/**
+ * @import {
+ * 	HttpUriPluginOptions
+ * } from "../../declarations/plugins/schemes/HttpUriPlugin"
+ */
+/** @import Compiler from "../Compiler" */
+/** @import { Snapshot } from "../FileSystemInfo" */
+/** @import { ResourceDataWithData } from "../NormalModuleFactory" */
+/** @import { IntermediateFileSystem } from "../util/fs" */
+/** @import { NormalModuleBuildInfo } from "../NormalModule" */
 
 const MAX_REDIRECTS = 5;
 
@@ -482,7 +491,7 @@ const cachedWithKey = (fn, forceFn = fn) => {
  * Defines the lockfile cache type used by this module.
  * @typedef {object} LockfileCache
  * @property {Lockfile} lockfile lockfile
- * @property {Snapshot} snapshot snapshot
+ * @property {InstanceType<Snapshot>} snapshot snapshot
  */
 
 /**
@@ -644,7 +653,7 @@ class HttpUriPlugin {
 											: new Lockfile();
 										lockfileCache = {
 											lockfile,
-											snapshot: /** @type {Snapshot} */ (s)
+											snapshot: /** @type {InstanceType<Snapshot>} */ (s)
 										};
 										callback(null, lockfile);
 									}

package/lib/schemes/VirtualUrlPlugin.js

@@ -6,21 +6,27 @@
 "use strict";
 
 const NormalModule = require("../NormalModule");
-const ModuleNotFoundError = require("../errors/ModuleNotFoundError");
+
 const { getContext } = require("../loaders/LoaderRunner");
 const { isAbsolute, join } = require("../util/fs");
 const { parseResourceWithoutFragment } = require("../util/identifier");
+const memoize = require("../util/memoize");
+
+const getModuleNotFoundError = memoize(() =>
+	require("../errors/ModuleNotFoundError")
+);
 
 const DEFAULT_SCHEME = "virtual";
 
 const PLUGIN_NAME = "VirtualUrlPlugin";
 
+/** @import Compiler from "../Compiler" */
 /**
- * Defines the compiler type used by this module.
- * @typedef {import("../Compiler")} Compiler
- * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualModule} VirtualModuleConfig
- * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualModuleContent} VirtualModuleInput
- * @typedef {import("../../declarations/plugins/schemes/VirtualUrlPlugin").VirtualUrlOptions} VirtualUrlOptions
+ * @import {
+ * 	VirtualModule as VirtualModuleConfig,
+ * 	VirtualModuleContent as VirtualModuleInput,
+ * 	VirtualUrlOptions
+ * } from "../../declarations/plugins/schemes/VirtualUrlPlugin"
  */
 
 /** @typedef {(loaderContext: LoaderContext<EXPECTED_ANY>) => Promise<string | Buffer> | string | Buffer} SourceFn */
@@ -271,7 +277,7 @@ class VirtualUrlPlugin {
 	findVirtualModuleConfigById(id) {
 		const config = this.modules[id];
 		if (!config) {
-			throw new ModuleNotFoundError(
+			throw new (getModuleNotFoundError())(
 				null,
 				new Error(`Can't resolve virtual module ${id}`),
 				{

package/lib/serialization/AggregateErrorSerializer.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
+/** @import { ComplexSerializableType } from "./types" */
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<ComplexSerializableType[]>} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<ComplexSerializableType[]>} ObjectSerializerContext */
 

package/lib/serialization/BinaryMiddleware.js

@@ -8,8 +8,8 @@ const { deserialize: v8Deserialize, serialize: v8Serialize } = require("v8");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
+/** @import { BufferSerializableType } from "./types" */
 
 /*
 Format:
@@ -579,7 +579,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 	}
 }
 
-module.exports = BinaryMiddleware;
+BinaryMiddleware.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
+BinaryMiddleware.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
 
-module.exports.MEASURE_END_OPERATION = MEASURE_END_OPERATION;
-module.exports.MEASURE_START_OPERATION = MEASURE_START_OPERATION;
+module.exports = BinaryMiddleware;

package/lib/serialization/ErrorObjectSerializer.js

@@ -4,7 +4,7 @@
 
 "use strict";
 
-/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
+/** @import { ComplexSerializableType } from "./types" */
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<ComplexSerializableType[]>} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<ComplexSerializableType[]>} ObjectSerializerContext */
 

package/lib/serialization/FileMiddleware.js

@@ -31,10 +31,9 @@ const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
-/** @typedef {import("../util/fs").IStats} IStats */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-/** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { IStats, IntermediateFileSystem } from "../util/fs" */
+/** @import { BufferSerializableType } from "./types" */
 
 /*
 Format:
@@ -1046,7 +1045,8 @@ const getReferencedFilenames = (fs, file) =>
 		? getReferencedFilenamesCompressed(fs, file)
 		: getReferencedFilenamesUncompressed(fs, file);
 
-module.exports = FileMiddleware;
 // Exposed for testing the content-buffer boundary handling in `deserialize`.
-module.exports._deserialize = deserialize;
-module.exports.getReferencedFilenames = getReferencedFilenames;
+FileMiddleware._deserialize = deserialize;
+FileMiddleware.getReferencedFilenames = getReferencedFilenames;
+
+module.exports = FileMiddleware;

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
 				});
 			}
 		}