webpack 5.111.1 → 5.112.1

package/lib/serialization/AggregateErrorSerializer.js

@@ -8,7 +8,7 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<ComplexSerializableType[]>} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<ComplexSerializableType[]>} ObjectSerializerContext */
 
-/** @typedef {Error & { cause?: unknown, errors: EXPECTED_ANY[] }} AggregateError */
+/** @typedef {Error & { cause?: ComplexSerializableType, errors: ComplexSerializableType[] }} AggregateError */
 
 class AggregateErrorSerializer {
 	/**
@@ -20,7 +20,7 @@ class AggregateErrorSerializer {
 		context.write(obj.errors);
 		context.write(obj.message);
 		context.write(obj.stack);
-		context.write(/** @type {ComplexSerializableType} */ (obj.cause));
+		context.write(obj.cause);
 	}
 
 	/**
@@ -29,7 +29,7 @@ class AggregateErrorSerializer {
 	 * @returns {AggregateError} error
 	 */
 	deserialize(context) {
-		const errors = /** @type {EXPECTED_ANY[]} */ (context.read());
+		const errors = /** @type {ComplexSerializableType[]} */ (context.read());
 		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax, unicorn/error-message
 		const err = new AggregateError(errors);
 
@@ -37,7 +37,7 @@ class AggregateErrorSerializer {
 		err.stack = /** @type {string | undefined} */ (context.read());
 		err.cause = context.read();
 
-		return err;
+		return /** @type {AggregateError} */ (err);
 	}
 }
 

package/lib/serialization/BinaryMiddleware.js

@@ -484,7 +484,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 				sectionStart = i + 1;
 				const operation =
 					/** @type {MEASURE_START_OPERATION_TYPE | MEASURE_END_OPERATION_TYPE} */
-					(/** @type {unknown} */ (thing));
+					(
+						/** @type {typeof thing | MEASURE_START_OPERATION_TYPE | MEASURE_END_OPERATION_TYPE} */
+						(thing)
+					);
 				if (operation === MEASURE_START_OPERATION) {
 					measureStack.push(writtenBytes);
 				} else if (operation === MEASURE_END_OPERATION) {

package/lib/serialization/ErrorObjectSerializer.js

@@ -8,7 +8,7 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<ComplexSerializableType[]>} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<ComplexSerializableType[]>} ObjectSerializerContext */
 
-/** @typedef {Error & { cause?: unknown }} ErrorWithCause */
+/** @typedef {Error & { cause?: ComplexSerializableType }} ErrorWithCause */
 
 class ErrorObjectSerializer {
 	/**
@@ -27,10 +27,7 @@ class ErrorObjectSerializer {
 	serialize(obj, context) {
 		context.write(obj.message);
 		context.write(obj.stack);
-		context.write(
-			/** @type {ComplexSerializableType} */
-			(/** @type {ErrorWithCause} */ (obj).cause)
-		);
+		context.write(/** @type {ErrorWithCause} */ (obj).cause);
 	}
 
 	/**

package/lib/serialization/FileMiddleware.js

@@ -42,13 +42,13 @@ const {
 	zstdDecompress
 } = require("zlib");
 const { DEFAULTS } = require("../config/defaults");
+const { dirname, join, mkdirp } = require("../fs/fs");
 const createHash = require("../util/createHash");
-const { dirname, join, mkdirp } = require("../util/fs");
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
 /** @import { HashFunction } from "../util/Hash" */
-/** @import { IStats, IntermediateFileSystem } from "../util/fs" */
+/** @import { IStats, IntermediateFileSystem } from "../fs/fs" */
 /** @import { BufferSerializableType } from "./types" */
 
 // "wpc" + 1 in little-endian
@@ -1013,7 +1013,7 @@ const getReferencedFilenamesUncompressed = (fs, file) =>
 					// otherwise pointer reads land on wrong bytes and under-report
 					fs.stat(file, (err, stats) => {
 						if (err) return fail(err);
-						const stat = /** @type {import("../util/fs").IStats} */ (stats);
+						const stat = /** @type {import("../fs/fs").IStats} */ (stats);
 						if (stat.size !== position) {
 							return fail(
 								new Error(`Section table does not match size of ${file}`)

package/lib/serialization/ObjectMiddleware.js

@@ -41,7 +41,7 @@ const SetObjectSerializer = require("./SetObjectSerializer");
 
 /** @import { Logger } from "../logging/Logger" */
 /** @import { HashFunction } from "../util/Hash" */
-/** @import { LazyOptions } from "./SerializerMiddleware" */
+/** @import { LazyOptions, LazyTarget } from "./SerializerMiddleware" */
 /**
  * @import {
  * 	ComplexSerializableType,
@@ -49,7 +49,7 @@ const SetObjectSerializer = require("./SetObjectSerializer");
  * } from "./types"
  */
 
-/** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
+/** @typedef {abstract new (...params: never[]) => EXPECTED_OBJECT} Constructor */
 
 /**
  * Defines the object serializer snapshot type used by this module.
@@ -65,35 +65,36 @@ const SetObjectSerializer = require("./SetObjectSerializer");
 /** @typedef {EXPECTED_OBJECT | string} ReferenceableItem */
 
 /**
- * First tuple element; element type for an open array; `EXPECTED_ANY` once exhausted.
- * @template {readonly EXPECTED_ANY[]} T
- * @typedef {T extends readonly [infer H, ...EXPECTED_ANY[]] ? H : T extends readonly [] ? EXPECTED_ANY : T extends readonly (infer E)[] ? E : never} Head
+ * First tuple element; element type for an open array; `never` once exhausted,
+ * so a read or write past the declared tuple fails to type-check.
+ * @template T
+ * @typedef {T extends readonly [infer H, ...infer _Rest] ? H : T extends readonly [] ? never : T extends readonly (infer E)[] ? E : never} Head
  */
 
 /**
  * Tuple without its first element; unchanged when `T` is an open array.
- * @template {readonly EXPECTED_ANY[]} T
- * @typedef {T extends readonly [EXPECTED_ANY, ...infer R] ? R : T} Tail
+ * @template T
+ * @typedef {T extends readonly [infer _First, ...infer R] ? R : T} Tail
  */
 
 /**
  * Defines the object serializer context type used by this module.
  * `T` is the tuple of values written in order; each `write` consumes the head.
- * @template {readonly EXPECTED_ANY[]} [T=readonly EXPECTED_ANY[]]
+ * @template [T=readonly EXPECTED_ANY[]]
  * @typedef {object} ObjectSerializerContext
  * @property {(value: Head<T>) => ObjectSerializerContext<Tail<T>>} write
  * @property {(value: ReferenceableItem) => void} setCircularReference
  * @property {() => ObjectSerializerSnapshot} snapshot
  * @property {(snapshot: ObjectSerializerSnapshot) => void} rollback
- * @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
+ * @property {((item: ComplexSerializableType) => void)=} writeLazy
+ * @property {((item: ComplexSerializableType, obj: LazyOptions | undefined) => import("./SerializerMiddleware").LazyFunction<EXPECTED_ANY, PrimitiveSerializableType[], LazyTarget, LazyOptions>)=} writeSeparate
  */
 
 /**
  * Defines the object deserializer context type used by this module.
  * `T` is the tuple of values read in order: `read` returns the head, and `rest`
  * re-types the same context to `Tail<T>` so successive reads stay positional.
- * @template {readonly EXPECTED_ANY[]} [T=readonly EXPECTED_ANY[]]
+ * @template [T=readonly EXPECTED_ANY[]]
  * @typedef {object} ObjectDeserializerContext
  * @property {() => Head<T>} read
  * @property {ObjectDeserializerContext<Tail<T>>} rest
@@ -102,9 +103,9 @@ const SetObjectSerializer = require("./SetObjectSerializer");
 
 /**
  * Defines the object serializer type used by this module.
- * @typedef {object} ObjectSerializer
- * @property {(value: EXPECTED_ANY, context: ObjectSerializerContext<EXPECTED_ANY>) => void} serialize
- * @property {(context: ObjectDeserializerContext<EXPECTED_ANY>) => EXPECTED_ANY} deserialize
+ * Methods, so a serializer may narrow `value` to the class it is registered for.
+ * @template {EXPECTED_OBJECT} [T=EXPECTED_OBJECT]
+ * @typedef {{ serialize(value: T, context: ObjectSerializerContext): void, deserialize(context: ObjectDeserializerContext): EXPECTED_OBJECT }} ObjectSerializer
  */
 
 /**
@@ -223,7 +224,7 @@ const loaders = new Map();
 /** @typedef {PrimitiveSerializableType[]} SerializedType */
 /** @typedef {{ logger: Logger }} Context */
 
-/** @typedef {(context: ObjectSerializerContext<EXPECTED_ANY> | ObjectDeserializerContext<EXPECTED_ANY>) => void} ExtendContext */
+/** @typedef {(context: ObjectSerializerContext<ComplexSerializableType[]> | ObjectDeserializerContext<ComplexSerializableType[]>) => void} ExtendContext */
 
 /**
  * Represents ObjectMiddleware.
@@ -255,10 +256,11 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 	/**
 	 * Processes the provided constructor.
-	 * @param {Constructor} Constructor the constructor
+	 * @template {Constructor} C
+	 * @param {C} Constructor the constructor
 	 * @param {string} request the request which will be required when deserializing
 	 * @param {string | null} name the name to make multiple serializer unique when sharing a request
-	 * @param {ObjectSerializer} serializer the serializer
+	 * @param {ObjectSerializer<InstanceType<C>>} serializer the serializer
 	 * @returns {void}
 	 */
 	static register(Constructor, request, name, serializer) {
@@ -285,6 +287,37 @@ class ObjectMiddleware extends SerializerMiddleware {
 		serializerInversed.set(key, serializer);
 	}
 
+	/**
+	 * Accepts a historical request/name as an extra deserialization key for an
+	 * already registered constructor, so caches written before a move restore.
+	 * @param {Constructor} Constructor the constructor, already registered
+	 * @param {string} request the historical request
+	 * @param {(string | null)=} name the historical name
+	 * @returns {void}
+	 */
+	static registerLegacyRequest(Constructor, request, name = null) {
+		const config = serializers.get(Constructor);
+
+		if (config === undefined || config === NOT_SERIALIZABLE) {
+			throw new Error(
+				`ObjectMiddleware.registerLegacyRequest: serializer for ${Constructor.name} is not registered`
+			);
+		}
+
+		const key = `${request}/${name}`;
+
+		if (serializerInversed.has(key)) {
+			throw new Error(
+				`ObjectMiddleware.registerLegacyRequest: serializer for ${key} is already registered`
+			);
+		}
+
+		serializerInversed.set(
+			key,
+			/** @type {SerializerConfigWithSerializer} */ (config).serializer
+		);
+	}
+
 	/**
 	 * Register not serializable.
 	 * @param {Constructor} Constructor the constructor
@@ -302,7 +335,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 	/**
 	 * Gets serializer for.
-	 * @param {EXPECTED_ANY} object for serialization
+	 * @param {ComplexSerializableType} object for serialization
 	 * @returns {SerializerConfigWithSerializer} Serializer config
 	 */
 	static getSerializerFor(object) {
@@ -335,7 +368,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	/**
 	 * Gets deserializer for.
 	 * @param {string} request request
-	 * @param {string} name name
+	 * @param {string | null} name name
 	 * @returns {ObjectSerializer} serializer
 	 */
 	static getDeserializerFor(request, name) {
@@ -352,7 +385,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 	/**
 	 * Get deserializer for without error.
 	 * @param {string} request request
-	 * @param {string} name name
+	 * @param {string | null} name name
 	 * @returns {ObjectSerializer | undefined} serializer
 	 */
 	static _getDeserializerForWithoutError(request, name) {
@@ -491,13 +524,13 @@ class ObjectMiddleware extends SerializerMiddleware {
 								return `Object { ${Object.keys(item).join(", ")} }`;
 							}
 							if (item.constructor === Map) {
-								return `Map { ${/** @type {Map<EXPECTED_ANY, EXPECTED_ANY>} */ (item).size} items }`;
+								return `Map { ${/** @type {Map<ComplexSerializableType, ComplexSerializableType>} */ (item).size} items }`;
 							}
 							if (item.constructor === Array) {
-								return `Array { ${/** @type {EXPECTED_ANY[]} */ (item).length} items }`;
+								return `Array { ${/** @type {ComplexSerializableType[]} */ (item).length} items }`;
 							}
 							if (item.constructor === Set) {
-								return `Set { ${/** @type {Set<EXPECTED_ANY>} */ (item).size} items }`;
+								return `Set { ${/** @type {Set<ComplexSerializableType>} */ (item).size} items }`;
 							}
 							if (item.constructor === RegExp) {
 								return /** @type {RegExp} */ (item).toString();
@@ -542,7 +575,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 		/**
 		 * Writes one item into the output; the context is returned so writes chain.
 		 * @param {ComplexSerializableType} item item to serialize
-		 * @returns {ObjectSerializerContext<EXPECTED_ANY>} context
+		 * @returns {ObjectSerializerContext<ComplexSerializableType[]>} context
 		 */
 		const process = (item) => {
 			switch (typeof item) {
@@ -723,7 +756,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 			}
 			return ctx;
 		};
-		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
+		/** @type {ObjectSerializerContext<ComplexSerializableType[]>} */
 		let ctx = {
 			write: process,
 			setCircularReference(ref) {
@@ -780,7 +813,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				bufferDedupeMap =
 				objectTypeLookup =
 				ctx =
-					/** @type {EXPECTED_ANY} */
+					/** @type {never} */
 					(undefined);
 		}
 	}
@@ -821,10 +854,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let objectTypeLookup = [];
 		/** @type {ComplexSerializableType[]} */
 		let result = [];
-		/** @type {ObjectDeserializerContext<EXPECTED_ANY>} */
+		/** @type {ObjectDeserializerContext<ComplexSerializableType[]>} */
 		let ctx = {
 			read() {
-				return /** @type {EXPECTED_ANY} */ (decodeValue());
+				return decodeValue();
 			},
 			// type-only cursor advance; same object, retyped to the tuple tail
 			get rest() {
@@ -980,7 +1013,7 @@ class ObjectMiddleware extends SerializerMiddleware {
 				data =
 				objectTypeLookup =
 				ctx =
-					/** @type {EXPECTED_ANY} */
+					/** @type {never} */
 					(undefined);
 		}
 	}

package/lib/serialization/PlainObjectSerializer.js

@@ -5,7 +5,7 @@
 "use strict";
 /** @import { ObjectDeserializerContext, ObjectSerializerContext } from "./ObjectMiddleware" */
 
-/** @typedef {ObjectSerializerContext<EXPECTED_ANY>["write"]} CacheAssoc */
+/** @typedef {(value: never) => EXPECTED_OBJECT} CacheAssoc */
 
 /**
  * Defines the shared type used by this module.
@@ -114,14 +114,10 @@ class PlainObjectSerializer {
 		const obj = /** @type {T} */ ({});
 		if (Array.isArray(keys)) {
 			for (const key of keys) {
-				obj[/** @type {keyof T} */ (key)] = /** @type {T[keyof T]} */ (
-					context.read()
-				);
+				obj[key] = /** @type {T[keyof T]} */ (context.read());
 			}
 		} else if (keys !== null) {
-			obj[/** @type {keyof T} */ (keys)] = /** @type {T[keyof T]} */ (
-				context.read()
-			);
+			obj[keys] = /** @type {T[keyof T]} */ (context.read());
 		}
 		return obj;
 	}

package/lib/serialization/Serializer.js

@@ -6,10 +6,14 @@
 
 /**
  * Defines the serializer middleware type used by this module.
- * @template T, K, C
+ * @template [T=ComplexSerializableType]
+ * @template [K=ComplexSerializableType]
+ * @template [C=EXPECTED_OBJECT]
  * @typedef {import("./SerializerMiddleware")<T, K, C>} SerializerMiddleware
  */
 
+/** @import { ComplexSerializableType } from "./types" */
+
 /**
  * Represents Serializer.
  * @template DeserializedValue
@@ -19,7 +23,7 @@
 class Serializer {
 	/**
 	 * Creates an instance of Serializer.
-	 * @param {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>[]} middlewares serializer middlewares
+	 * @param {SerializerMiddleware[]} middlewares serializer middlewares
 	 * @param {Context=} context context
 	 */
 	constructor(middlewares, context) {
@@ -38,15 +42,18 @@ class Serializer {
 	 */
 	serialize(obj, context) {
 		const ctx = { ...context, ...this.context };
-		let current = obj;
+		let current =
+			/** @type {ComplexSerializableType | Promise<ComplexSerializableType>} */
+			(obj);
 		for (const middleware of this.serializeMiddlewares) {
 			if (
 				current &&
-				typeof (/** @type {Promise<DeserializedValue>} */ (current).then) ===
-					"function"
+				typeof (
+					/** @type {Promise<ComplexSerializableType>} */ (current).then
+				) === "function"
 			) {
 				current =
-					/** @type {Promise<DeserializedValue>} */
+					/** @type {Promise<ComplexSerializableType>} */
 					(current).then((data) => data && middleware.serialize(data, ctx));
 			} else if (current) {
 				try {
@@ -70,14 +77,17 @@ class Serializer {
 	 */
 	deserialize(value, context) {
 		const ctx = { ...context, ...this.context };
-		let current = value;
+		let current =
+			/** @type {ComplexSerializableType | Promise<ComplexSerializableType>} */
+			(value);
 		for (const middleware of this.deserializeMiddlewares) {
 			current =
 				current &&
-				typeof (/** @type {Promise<SerializedValue>} */ (current).then) ===
-					"function"
-					? /** @type {Promise<SerializedValue>} */ (current).then((data) =>
-							middleware.deserialize(data, ctx)
+				typeof (
+					/** @type {Promise<ComplexSerializableType>} */ (current).then
+				) === "function"
+					? /** @type {Promise<ComplexSerializableType>} */ (current).then(
+							(data) => middleware.deserialize(data, ctx)
 						)
 					: middleware.deserialize(current, ctx);
 		}

package/lib/serialization/SerializerMiddleware.js

@@ -9,8 +9,10 @@ const memoize = require("../util/memoize");
 const LAZY_TARGET = Symbol("lazy serialization target");
 const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
-/** @typedef {SerializerMiddleware<EXPECTED_ANY, EXPECTED_ANY, Record<string, EXPECTED_ANY>>} LazyTarget */
-/** @typedef {Record<string, EXPECTED_ANY>} LazyOptions */
+/** @import { ComplexSerializableType } from "./types" */
+
+/** @typedef {SerializerMiddleware} LazyTarget */
+/** @typedef {{ name?: string, size?: number }} LazyOptions */
 
 /**
  * Defines the lazy function type used by this module.
@@ -23,9 +25,9 @@ const LAZY_SERIALIZED_VALUE = Symbol("lazy serialization data");
 
 /**
  * Represents SerializerMiddleware.
- * @template DeserializedType
- * @template SerializedType
- * @template Context
+ * @template [DeserializedType=ComplexSerializableType]
+ * @template [SerializedType=ComplexSerializableType]
+ * @template [Context=EXPECTED_OBJECT]
  */
 class SerializerMiddleware {
 	/* istanbul ignore next */
@@ -102,7 +104,7 @@ class SerializerMiddleware {
 	 * @template TLazyInputValue
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
-	 * @template {Record<string, EXPECTED_ANY>} TLazyOptions
+	 * @template {LazyOptions} TLazyOptions
 	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
 	 * @returns {LazyOptions | undefined} options
 	 */
@@ -117,8 +119,8 @@ class SerializerMiddleware {
 	 * @template TLazyOutputValue
 	 * @template {LazyTarget} TLazyTarget
 	 * @template {LazyOptions} TLazyOptions
-	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions> | EXPECTED_ANY} fn lazy function
-	 * @returns {TLazyOutputValue | undefined} serialized value
+	 * @param {LazyFunction<TLazyInputValue, TLazyOutputValue, TLazyTarget, TLazyOptions>} fn lazy function
+	 * @returns {TLazyOutputValue | LazyFunction<TLazyOutputValue, TLazyInputValue, TLazyTarget, TLazyOptions> | undefined} serialized value
 	 */
 	static getLazySerializedValue(fn) {
 		if (typeof fn !== "function") return;

package/lib/serialization/SingleItemMiddleware.js

@@ -6,8 +6,10 @@
 
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {EXPECTED_ANY} DeserializedType */
-/** @typedef {EXPECTED_ANY[]} SerializedType */
+/** @import { ComplexSerializableType } from "./types" */
+
+/** @typedef {ComplexSerializableType} DeserializedType */
+/** @typedef {ComplexSerializableType[]} SerializedType */
 /** @typedef {EXPECTED_OBJECT} Context */
 
 /**

package/lib/sharing/ConsumeSharedFallbackDependency.js

@@ -5,7 +5,9 @@
 
 "use strict";
 
-const ModuleDependency = require("../dependencies/ModuleDependency");
+/** @import { DependencyKinds } from "../graph/Dependency" */
+
+const ModuleDependency = require("../dependencies/core/ModuleDependency");
 const makeSerializable = require("../util/makeSerializable");
 
 class ConsumeSharedFallbackDependency extends ModuleDependency {
@@ -31,4 +33,10 @@ makeSerializable(
 	"webpack/lib/sharing/ConsumeSharedFallbackDependency"
 );
 
+/** @type {Set<keyof DependencyKinds>} */
+ConsumeSharedFallbackDependency.KINDS = new Set([
+	...ModuleDependency.KINDS,
+	"sharing-request"
+]);
+
 module.exports = ConsumeSharedFallbackDependency;

package/lib/sharing/ConsumeSharedModule.js

@@ -6,19 +6,19 @@
 "use strict";
 
 const { RawSource } = require("webpack-sources");
-const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
-const Module = require("../Module");
+const AsyncDependenciesBlock = require("../graph/AsyncDependenciesBlock");
+const Module = require("../module/Module");
 const {
 	CONSUME_SHARED_TYPES,
 	JAVASCRIPT_TYPES
-} = require("../ModuleSourceTypeConstants");
+} = require("../module/ModuleSourceTypeConstants");
 const {
 	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
-} = require("../ModuleTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
+} = require("../module/ModuleTypeConstants");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
-const { rangeToString, stringifyHoley } = require("../util/semver");
 const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependency");
+const { rangeToString, stringifyHoley } = require("./semver");
 
 /** @type {WeakMap<ModuleGraph, WeakMap<ConsumeSharedModule, Module | null>>} */
 const fallbackModuleCache = new WeakMap();
@@ -29,7 +29,7 @@ const fallbackModuleCache = new WeakMap();
  * } from "../config/defaults"
  */
 /** @import Compilation from "../Compilation" */
-/** @import { UpdateHashContext } from "../Dependency" */
+/** @import { UpdateHashContext } from "../graph/Dependency" */
 /**
  * @import {
  * 	BuildCallback,
@@ -42,17 +42,18 @@ const fallbackModuleCache = new WeakMap();
  * 	Sources,
  * 	SourceTypes,
  * 	ExportsType,
- * 	BasicSourceTypes
- * } from "../Module"
+ * 	BasicSourceTypes,
+ * 	ModuleKinds
+ * } from "../module/Module"
  */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import RequestShortener from "../RequestShortener" */
-/** @import { ResolverWithOptions } from "../ResolverFactory" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import { ResolverWithOptions } from "../resolve/ResolverFactory" */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ConsumeOptions]>} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ConsumeOptions]>} ObjectSerializerContext */
 /** @import Hash from "../util/Hash" */
-/** @import { InputFileSystem } from "../util/fs" */
-/** @import { SemVerRange } from "../util/semver" */
+/** @import { InputFileSystem } from "../fs/fs" */
+/** @import { SemVerRange } from "./semver" */
 
 /**
  * Represents the consume shared module runtime component.
@@ -364,4 +365,7 @@ makeSerializable(
 	"webpack/lib/sharing/ConsumeSharedModule"
 );
 
+/** @type {Set<keyof ModuleKinds>} */
+ConsumeSharedModule.KINDS = new Set([...Module.KINDS, "consume-shared"]);
+
 module.exports = ConsumeSharedModule;