webpack 5.81.0 → 5.82.1

package/lib/javascript/JavascriptParser.js

@@ -102,12 +102,46 @@ class VariableInfo {
  * @property {boolean} inTry
  */
 
+/**
+ * Helper function for joining two ranges into a single range. This is useful
+ * when working with AST nodes, as it allows you to combine the ranges of child nodes
+ * to create the range of the _parent node_.
+ *
+ * @param {[number, number]} startRange start range to join
+ * @param {[number, number]} endRange end range to join
+ * @returns {[number, number]} joined range
+ *
+ * @example
+ * ```js
+ * 	const startRange = [0, 5];
+ * 	const endRange = [10, 15];
+ * 	const joinedRange = joinRanges(startRange, endRange);
+ * 	console.log(joinedRange); // [0, 15]
+ * ```
+ *
+ */
 const joinRanges = (startRange, endRange) => {
 	if (!endRange) return startRange;
 	if (!startRange) return endRange;
 	return [startRange[0], endRange[1]];
 };
 
+/**
+ * Helper function used to generate a string representation of a
+ * [member expression](https://github.com/estree/estree/blob/master/es5.md#memberexpression).
+ *
+ * @param {string} object object to name
+ * @param {string[]} membersReversed reversed list of members
+ * @returns {string} member expression as a string
+ * @example
+ * ```js
+ * const membersReversed = ["property1", "property2", "property3"]; // Members parsed from the AST
+ * const name = objectAndMembersToName("myObject", membersReversed);
+ *
+ * console.log(name); // "myObject.property1.property2.property3"
+ * ```
+ *
+ */
 const objectAndMembersToName = (object, membersReversed) => {
 	let name = object;
 	for (let i = membersReversed.length - 1; i >= 0; i--) {
@@ -116,6 +150,16 @@ const objectAndMembersToName = (object, membersReversed) => {
 	return name;
 };
 
+/**
+ * Grabs the name of a given expression and returns it as a string or undefined. Has particular
+ * handling for [Identifiers](https://github.com/estree/estree/blob/master/es5.md#identifier),
+ * [ThisExpressions](https://github.com/estree/estree/blob/master/es5.md#identifier), and
+ * [MetaProperties](https://github.com/estree/estree/blob/master/es2015.md#metaproperty) which is
+ * specifically for handling the `new.target` meta property.
+ *
+ * @param {ExpressionNode | SuperNode} expression expression
+ * @returns {string | "this" | undefined} name or variable info
+ */
 const getRootName = expression => {
 	switch (expression.type) {
 		case "Identifier":
@@ -469,6 +513,49 @@ class JavascriptParser extends Parser {
 				}
 			});
 
+		/**
+		 * In simple logical cases, we can use valueAsExpression to assist us in evaluating the expression on
+		 * either side of a [BinaryExpression](https://github.com/estree/estree/blob/master/es5.md#binaryexpression).
+		 * This supports scenarios in webpack like conditionally `import()`'ing modules based on some simple evaluation:
+		 *
+		 * ```js
+		 * if (1 === 3) {
+		 *  import("./moduleA"); // webpack will auto evaluate this and not import the modules
+		 * }
+		 * ```
+		 *
+		 * Additional scenarios include evaluation of strings inside of dynamic import statements:
+		 *
+		 * ```js
+		 * const foo = "foo";
+		 * const bar = "bar";
+		 *
+		 * import("./" + foo + bar); // webpack will auto evaluate this into import("./foobar")
+		 * ```
+		 * @param {boolean | number | BigInt | string} value the value to convert to an expression
+		 * @param {BinaryExpressionNode | UnaryExpressionNode} expr the expression being evaluated
+		 * @param {boolean} sideEffects whether the expression has side effects
+		 * @returns {BasicEvaluatedExpression} the evaluated expression
+		 * @example
+		 *
+		 * ```js
+		 * const binaryExpr = new BinaryExpressionNode("+",
+		 * 	{ type: "Literal", value: 2 },
+		 * 	{ type: "Literal", value: 3 }
+		 * );
+		 *
+		 * const leftValue = 2;
+		 * const rightValue = 3;
+		 *
+		 * const leftExpr = valueAsExpression(leftValue, binaryExpr.left, false);
+		 * const rightExpr = valueAsExpression(rightValue, binaryExpr.right, false);
+		 * const result = new BasicEvaluatedExpression()
+		 * 	.setNumber(leftExpr.number + rightExpr.number)
+		 * 	.setRange(binaryExpr.range);
+		 *
+		 * console.log(result.number); // Output: 5
+		 * ```
+		 */
 		const valueAsExpression = (value, expr, sideEffects) => {
 			switch (typeof value) {
 				case "boolean":
@@ -499,14 +586,21 @@ class JavascriptParser extends Parser {
 			.tap("JavascriptParser", _expr => {
 				const expr = /** @type {BinaryExpressionNode} */ (_expr);
 
-				const handleConstOperation = fn => {
+				/**
+				 * Evaluates a binary expression if and only if it is a const operation (e.g. 1 + 2, "a" + "b", etc.).
+				 *
+				 * @template T
+				 * @param {(leftOperand: T, rightOperand: T) => boolean | number | BigInt | string} operandHandler the handler for the operation (e.g. (a, b) => a + b)
+				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+				 */
+				const handleConstOperation = operandHandler => {
 					const left = this.evaluateExpression(expr.left);
 					if (!left.isCompileTimeValue()) return;
 
 					const right = this.evaluateExpression(expr.right);
 					if (!right.isCompileTimeValue()) return;
 
-					const result = fn(
+					const result = operandHandler(
 						left.asCompileTimeValue(),
 						right.asCompileTimeValue()
 					);
@@ -517,6 +611,14 @@ class JavascriptParser extends Parser {
 					);
 				};
 
+				/**
+				 * Helper function to determine if two booleans are always different. This is used in `handleStrictEqualityComparison`
+				 * to determine if an expressions boolean or nullish conversion is equal or not.
+				 *
+				 * @param {boolean} a first boolean to compare
+				 * @param {boolean} b second boolean to compare
+				 * @returns {boolean} true if the two booleans are always different, false otherwise
+				 */
 				const isAlwaysDifferent = (a, b) =>
 					(a === true && b === false) || (a === false && b === true);
 
@@ -545,11 +647,13 @@ class JavascriptParser extends Parser {
 					const rightSuffix = getSuffix(right.parts);
 					const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
 					const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
-					if (
-						leftPrefix.slice(0, lenPrefix) !==
-							rightPrefix.slice(0, lenPrefix) ||
-						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix)
-					) {
+					const prefixMismatch =
+						lenPrefix > 0 &&
+						leftPrefix.slice(0, lenPrefix) !== rightPrefix.slice(0, lenPrefix);
+					const suffixMismatch =
+						lenSuffix > 0 &&
+						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix);
+					if (prefixMismatch || suffixMismatch) {
 						return res
 							.setBoolean(!eql)
 							.setSideEffects(
@@ -558,6 +662,11 @@ class JavascriptParser extends Parser {
 					}
 				};
 
+				/**
+				 * Helper function to handle BinaryExpressions using strict equality comparisons (e.g. "===" and "!==").
+				 * @param {boolean} eql true for "===" and false for "!=="
+				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+				 */
 				const handleStrictEqualityComparison = eql => {
 					const left = this.evaluateExpression(expr.left);
 					const right = this.evaluateExpression(expr.right);
@@ -611,6 +720,11 @@ class JavascriptParser extends Parser {
 					}
 				};
 
+				/**
+				 * Helper function to handle BinaryExpressions using abstract equality comparisons (e.g. "==" and "!=").
+				 * @param {boolean} eql true for "==" and false for "!="
+				 * @returns {BasicEvaluatedExpression | undefined} the evaluated expression
+				 */
 				const handleAbstractEqualityComparison = eql => {
 					const left = this.evaluateExpression(expr.left);
 					const right = this.evaluateExpression(expr.right);
@@ -823,10 +937,17 @@ class JavascriptParser extends Parser {
 			.tap("JavascriptParser", _expr => {
 				const expr = /** @type {UnaryExpressionNode} */ (_expr);
 
-				const handleConstOperation = fn => {
+				/**
+				 * Evaluates a UnaryExpression if and only if it is a basic const operator (e.g. +a, -a, ~a).
+				 *
+				 * @template T
+				 * @param {(operand: T) => boolean | number | BigInt | string} operandHandler handler for the operand
+				 * @returns {BasicEvaluatedExpression | undefined} evaluated expression
+				 */
+				const handleConstOperation = operandHandler => {
 					const argument = this.evaluateExpression(expr.argument);
 					if (!argument.isCompileTimeValue()) return;
-					const result = fn(argument.asCompileTimeValue());
+					const result = operandHandler(argument.asCompileTimeValue());
 					return valueAsExpression(
 						result,
 						expr,
@@ -1259,10 +1380,10 @@ class JavascriptParser extends Parser {
 						: "" + argExpr.number;
 
 					const newString = value + (stringSuffix ? stringSuffix.string : "");
-					const newRange = [
+					const newRange = /** @type {[number, number]} */ ([
 						argExpr.range[0],
 						(stringSuffix || argExpr).range[1]
-					];
+					]);
 					stringSuffix = new BasicEvaluatedExpression()
 						.setString(newString)
 						.setSideEffects(

package/lib/json/JsonData.js

@@ -7,9 +7,19 @@
 
 const { register } = require("../util/serialization");
 
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
+
 class JsonData {
+	/**
+	 * @param {Buffer | RawJsonData} data JSON data
+	 */
 	constructor(data) {
+		/** @type {Buffer | undefined} */
 		this._buffer = undefined;
+		/** @type {RawJsonData | undefined} */
 		this._data = undefined;
 		if (Buffer.isBuffer(data)) {
 			this._buffer = data;
@@ -18,6 +28,9 @@ class JsonData {
 		}
 	}
 
+	/**
+	 * @returns {RawJsonData|undefined} Raw JSON data
+	 */
 	get() {
 		if (this._data === undefined && this._buffer !== undefined) {
 			this._data = JSON.parse(this._buffer.toString());
@@ -25,6 +38,10 @@ class JsonData {
 		return this._data;
 	}
 
+	/**
+	 * @param {Hash} hash hash to be updated
+	 * @returns {Hash} the updated hash
+	 */
 	updateHash(hash) {
 		if (this._buffer === undefined && this._data !== undefined) {
 			this._buffer = Buffer.from(JSON.stringify(this._data));
@@ -35,12 +52,20 @@ class JsonData {
 }
 
 register(JsonData, "webpack/lib/json/JsonData", null, {
+	/**
+	 * @param {JsonData} obj JSONData object
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(obj, { write }) {
 		if (obj._buffer === undefined && obj._data !== undefined) {
 			obj._buffer = Buffer.from(JSON.stringify(obj._data));
 		}
 		write(obj._buffer);
 	},
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {JsonData} deserialized JSON data
+	 */
 	deserialize({ read }) {
 		return new JsonData(read());
 	}

package/lib/json/JsonGenerator.js

@@ -17,7 +17,13 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./JsonData")} JsonData */
+/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
 
+/**
+ * @param {RawJsonData} data Raw JSON data
+ * @returns {undefined|string} stringified data
+ */
 const stringifySafe = data => {
 	const stringified = JSON.stringify(data);
 	if (!stringified) {
@@ -30,10 +36,10 @@ const stringifySafe = data => {
 };
 
 /**
- * @param {Object} data data (always an object or array)
+ * @param {RawJsonData} data Raw JSON data (always an object or array)
  * @param {ExportsInfo} exportsInfo exports info
  * @param {RuntimeSpec} runtime the runtime
- * @returns {Object} reduced data
+ * @returns {RawJsonData} reduced data
  */
 const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
@@ -45,6 +51,7 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 		const used = exportInfo.getUsed(runtime);
 		if (used === UsageState.Unused) continue;
 
+		/** @type {any} */
 		let value;
 		if (used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo) {
 			value = createObjectForExportsInfo(
@@ -86,6 +93,7 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 					: { length: arrayLengthWhenUsed },
 				reducedData
 			);
+		/** @type {number} */
 		const generatedLength =
 			arrayLengthWhenUsed !== undefined
 				? Math.max(arrayLengthWhenUsed, reducedData.length)
@@ -116,7 +124,8 @@ class JsonGenerator extends Generator {
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
-		let data =
+		/** @type {RawJsonData | undefined} */
+		const data =
 			module.buildInfo &&
 			module.buildInfo.jsonData &&
 			module.buildInfo.jsonData.get();
@@ -148,6 +157,7 @@ class JsonGenerator extends Generator {
 			concatenationScope
 		}
 	) {
+		/** @type {RawJsonData | undefined} */
 		const data =
 			module.buildInfo &&
 			module.buildInfo.jsonData &&
@@ -160,6 +170,7 @@ class JsonGenerator extends Generator {
 			);
 		}
 		const exportsInfo = moduleGraph.getExportsInfo(module);
+		/** @type {RawJsonData} */
 		let finalJson =
 			typeof data === "object" &&
 			data &&
@@ -172,6 +183,7 @@ class JsonGenerator extends Generator {
 			jsonStr.length > 20 && typeof finalJson === "object"
 				? `JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
 				: jsonStr;
+		/** @type {string} */
 		let content;
 		if (concatenationScope) {
 			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${

package/lib/json/JsonModulesPlugin.js

@@ -11,6 +11,7 @@ const JsonGenerator = require("./JsonGenerator");
 const JsonParser = require("./JsonParser");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {Record<string, any>} RawJsonData */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/JsonModulesPluginParser.check.js"),

package/lib/json/JsonParser.js

@@ -13,6 +13,7 @@ const JsonData = require("./JsonData");
 /** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
 
 class JsonParser extends Parser {
 	/**
@@ -36,7 +37,7 @@ class JsonParser extends Parser {
 		/** @type {JsonModulesPluginParserOptions["parse"]} */
 		const parseFn =
 			typeof this.options.parse === "function" ? this.options.parse : parseJson;
-
+		/** @type {Buffer | RawJsonData} */
 		const data =
 			typeof source === "object"
 				? source

package/lib/library/ModuleLibraryPlugin.js

@@ -89,7 +89,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			)}`;
 			result.add(
 				`var ${varName} = __webpack_exports__${propertyAccess([
-					exportInfo.getUsedName(exportInfo.name, chunk.runtime)
+					/** @type {string} */
+					(exportInfo.getUsedName(exportInfo.name, chunk.runtime))
 				])};\n`
 			);
 			exports.push(`${varName} as ${exportInfo.name}`);

package/lib/node/ReadFileChunkLoadingRuntimeModule.js

@@ -178,7 +178,9 @@ class ReadFileChunkLoadingRuntimeModule extends RuntimeModule {
 												"});",
 												"promises.push(installedChunkData[2] = promise);"
 											]),
-											"} else installedChunks[chunkId] = 0;"
+											hasJsMatcher === true
+												? "}"
+												: "} else installedChunks[chunkId] = 0;"
 										]),
 										"}"
 									]),

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -132,6 +132,10 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				const s = JSON.stringify(str);
 				return s.slice(1, s.length - 1);
 			};
+			/**
+			 * @param {string} value string
+			 * @returns {function(number): string} string to put in quotes with length
+			 */
 			const unquotedStringifyWithLength = value => length =>
 				unquotedStringify(`${value}`.slice(0, length));
 			const chunkFilenameValue =

package/lib/runtime/GetTrustedTypesPolicyRuntimeModule.js

@@ -25,6 +25,9 @@ class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 		const { runtimeTemplate, outputOptions } = compilation;
 		const { trustedTypes } = outputOptions;
 		const fn = RuntimeGlobals.getTrustedTypesPolicy;
+		const wrapPolicyCreationInTryCatch = trustedTypes
+			? trustedTypes.onPolicyCreationFailure === "continue"
+			: false;
 
 		return Template.asString([
 			"var policy;",
@@ -58,9 +61,25 @@ class GetTrustedTypesPolicyRuntimeModule extends HelperRuntimeModule {
 						? [
 								'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
 								Template.indent([
-									`policy = trustedTypes.createPolicy(${JSON.stringify(
-										trustedTypes.policyName
-									)}, policy);`
+									...(wrapPolicyCreationInTryCatch ? ["try {"] : []),
+									...[
+										`policy = trustedTypes.createPolicy(${JSON.stringify(
+											trustedTypes.policyName
+										)}, policy);`
+									].map(line =>
+										wrapPolicyCreationInTryCatch ? Template.indent(line) : line
+									),
+									...(wrapPolicyCreationInTryCatch
+										? [
+												"} catch (e) {",
+												Template.indent([
+													`console.warn('Could not create trusted-types policy ${JSON.stringify(
+														trustedTypes.policyName
+													)}');`
+												]),
+												"}"
+										  ]
+										: [])
 								]),
 								"}"
 						  ]

package/lib/schemes/DataUriPlugin.js

@@ -13,6 +13,10 @@ const NormalModule = require("../NormalModule");
 // http://www.ietf.org/rfc/rfc2397.txt
 const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64))?,(.*)$/i;
 
+/**
+ * @param {string} uri data URI
+ * @returns {Buffer|null} decoded data
+ */
 const decodeDataURI = uri => {
 	const match = URIRegEx.exec(uri);
 	if (!match) return null;

package/lib/schemes/HttpUriPlugin.js

@@ -71,11 +71,19 @@ const validate = createSchemaValidation(
 	}
 );
 
+/**
+ * @param {string} str path
+ * @returns {string} safe path
+ */
 const toSafePath = str =>
 	str
 		.replace(/^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$/g, "")
 		.replace(/[^a-zA-Z0-9._-]+/g, "_");
 
+/**
+ * @param {Buffer} content content
+ * @returns {string} integrity
+ */
 const computeIntegrity = content => {
 	const hash = createHash("sha512");
 	hash.update(content);
@@ -83,6 +91,11 @@ const computeIntegrity = content => {
 	return integrity;
 };
 
+/**
+ * @param {Buffer} content content
+ * @param {string} integrity integrity
+ * @returns {boolean} true, if integrity matches
+ */
 const verifyIntegrity = (content, integrity) => {
 	if (integrity === "ignore") return true;
 	return computeIntegrity(content) === integrity;
@@ -110,6 +123,11 @@ const parseKeyValuePairs = str => {
 	return result;
 };
 
+/**
+ * @param {string | undefined} cacheControl Cache-Control header
+ * @param {number} requestTime timestamp of request
+ * @returns {{storeCache: boolean, storeLock: boolean, validUntil: number}} Logic for storing in cache and lockfile cache
+ */
 const parseCacheControl = (cacheControl, requestTime) => {
 	// When false resource is not stored in cache
 	let storeCache = true;
@@ -147,6 +165,10 @@ const areLockfileEntriesEqual = (a, b) => {
 	);
 };
 
+/**
+ * @param {LockfileEntry} entry lockfile entry
+ * @returns {`resolved: ${string}, integrity: ${string}, contentType: ${*}`} stringified entry
+ */
 const entryToString = entry => {
 	return `resolved: ${entry.resolved}, integrity: ${entry.integrity}, contentType: ${entry.contentType}`;
 };
@@ -158,6 +180,10 @@ class Lockfile {
 		this.entries = new Map();
 	}
 
+	/**
+	 * @param {string} content content of the lockfile
+	 * @returns {Lockfile} lockfile
+	 */
 	static parse(content) {
 		// TODO handle merge conflicts
 		const data = JSON.parse(content);
@@ -180,6 +206,9 @@ class Lockfile {
 		return lockfile;
 	}
 
+	/**
+	 * @returns {string} stringified lockfile
+	 */
 	toString() {
 		let str = "{\n";
 		const entries = Array.from(this.entries).sort(([a], [b]) =>
@@ -342,6 +371,7 @@ class HttpUriPlugin {
 				const fs = compilation.inputFileSystem;
 				const cache = compilation.getCache("webpack.HttpUriPlugin");
 				const logger = compilation.getLogger("webpack.HttpUriPlugin");
+				/** @type {string} */
 				const lockfileLocation =
 					this._lockfileLocation ||
 					join(
@@ -351,6 +381,7 @@ class HttpUriPlugin {
 							? `${toSafePath(compiler.name)}.webpack.lock`
 							: "webpack.lock"
 					);
+				/** @type {string | false} */
 				const cacheLocation =
 					this._cacheLocation !== undefined
 						? this._cacheLocation
@@ -364,6 +395,7 @@ class HttpUriPlugin {
 
 				let warnedAboutEol = false;
 
+				/** @type {Map<string, string>} */
 				const cacheKeyCache = new Map();
 				/**
 				 * @param {string} url the url
@@ -447,6 +479,12 @@ class HttpUriPlugin {
 
 				/** @type {Map<string, LockfileEntry | "ignore" | "no-cache"> | undefined} */
 				let lockfileUpdates = undefined;
+
+				/**
+				 * @param {Lockfile} lockfile lockfile instance
+				 * @param {string} url url to store
+				 * @param {LockfileEntry | "ignore" | "no-cache"} entry lockfile entry
+				 */
 				const storeLockEntry = (lockfile, url, entry) => {
 					const oldEntry = lockfile.entries.get(url);
 					if (lockfileUpdates === undefined) lockfileUpdates = new Map();

package/lib/sharing/ConsumeSharedModule.js

@@ -8,6 +8,9 @@
 const { RawSource } = require("webpack-sources");
 const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Module = require("../Module");
+const {
+	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const makeSerializable = require("../util/makeSerializable");
 const { rangeToString, stringifyHoley } = require("../util/semver");
@@ -52,7 +55,7 @@ class ConsumeSharedModule extends Module {
 	 * @param {ConsumeOptions} options consume options
 	 */
 	constructor(context, options) {
-		super("consume-shared-module", context);
+		super(WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE, context);
 		this.options = options;
 	}
 
@@ -69,7 +72,7 @@ class ConsumeSharedModule extends Module {
 			singleton,
 			eager
 		} = this.options;
-		return `consume-shared-module|${shareScope}|${shareKey}|${
+		return `${WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE}|${shareScope}|${shareKey}|${
 			requiredVersion && rangeToString(requiredVersion)
 		}|${strictVersion}|${importResolved}|${singleton}|${eager}`;
 	}

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");
@@ -39,7 +40,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;