webpack 5.81.0 → 5.82.1

package/lib/css/walkCssTokens.js

@@ -76,6 +76,10 @@ const CC_HYPHEN_MINUS = "-".charCodeAt(0);
 const CC_LESS_THAN_SIGN = "<".charCodeAt(0);
 const CC_GREATER_THAN_SIGN = ">".charCodeAt(0);
 
+/**
+ * @param {number} cc char code
+ * @returns {boolean} true, if cc is a newline
+ */
 const _isNewLine = cc => {
 	return (
 		cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED
@@ -84,6 +88,7 @@ const _isNewLine = cc => {
 
 /** @type {CharHandler} */
 const consumeSpace = (input, pos, callbacks) => {
+	/** @type {number} */
 	let cc;
 	do {
 		pos++;
@@ -92,17 +97,41 @@ const consumeSpace = (input, pos, callbacks) => {
 	return pos;
 };
 
-const _isWhiteSpace = cc => {
+/**
+ * @param {number} cc char code
+ * @returns {boolean} true, if cc is a newline
+ */
+const _isNewline = cc => {
 	return (
-		cc === CC_LINE_FEED ||
-		cc === CC_CARRIAGE_RETURN ||
-		cc === CC_FORM_FEED ||
-		cc === CC_TAB ||
-		cc === CC_SPACE
+		cc === CC_LINE_FEED || cc === CC_CARRIAGE_RETURN || cc === CC_FORM_FEED
 	);
 };
 
-const _isIdentStartCodePoint = cc => {
+/**
+ * @param {number} cc char code
+ * @returns {boolean} true, if cc is a space (U+0009 CHARACTER TABULATION or U+0020 SPACE)
+ */
+const _isSpace = cc => {
+	return cc === CC_TAB || cc === CC_SPACE;
+};
+
+/**
+ * @param {number} cc char code
+ * @returns {boolean} true, if cc is a whitespace
+ */
+const _isWhiteSpace = cc => {
+	return _isNewline(cc) || _isSpace(cc);
+};
+
+/**
+ * ident-start code point
+ *
+ * A letter, a non-ASCII code point, or U+005F LOW LINE (_).
+ *
+ * @param {number} cc char code
+ * @returns {boolean} true, if cc is a start code point of an identifier
+ */
+const isIdentStartCodePoint = cc => {
 	return (
 		(cc >= CC_LOWER_A && cc <= CC_LOWER_Z) ||
 		(cc >= CC_UPPER_A && cc <= CC_UPPER_Z) ||
@@ -145,21 +174,27 @@ const consumeComments = (input, pos, callbacks) => {
 };
 
 /** @type {function(number): CharHandler} */
-const consumeString = end => (input, pos, callbacks) => {
+const consumeString = quote_cc => (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeString(input, pos, end);
+	pos = _consumeString(input, pos, quote_cc);
 	if (callbacks.string !== undefined) {
 		pos = callbacks.string(input, start, pos);
 	}
 	return pos;
 };
 
-const _consumeString = (input, pos, end) => {
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @param {number} quote_cc quote char code
+ * @returns {number} new position
+ */
+const _consumeString = (input, pos, quote_cc) => {
 	pos++;
 	for (;;) {
 		if (pos === input.length) return pos;
 		const cc = input.charCodeAt(pos);
-		if (cc === end) return pos + 1;
+		if (cc === quote_cc) return pos + 1;
 		if (_isNewLine(cc)) {
 			// bad string
 			return pos;
@@ -176,6 +211,10 @@ const _consumeString = (input, pos, end) => {
 	}
 };
 
+/**
+ * @param {number} cc char code
+ * @returns {boolean} is identifier start code
+ */
 const _isIdentifierStartCode = cc => {
 	return (
 		cc === CC_LOW_LINE ||
@@ -185,16 +224,30 @@ const _isIdentifierStartCode = cc => {
 	);
 };
 
+/**
+ * @param {number} first first code point
+ * @param {number} second second code point
+ * @returns {boolean} true if two code points are a valid escape
+ */
 const _isTwoCodePointsAreValidEscape = (first, second) => {
 	if (first !== CC_REVERSE_SOLIDUS) return false;
 	if (_isNewLine(second)) return false;
 	return true;
 };
 
+/**
+ * @param {number} cc char code
+ * @returns {boolean} is digit
+ */
 const _isDigit = cc => {
 	return cc >= CC_0 && cc <= CC_9;
 };
 
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {boolean} true, if input at pos starts an identifier
+ */
 const _startsIdentifier = (input, pos) => {
 	const cc = input.charCodeAt(pos);
 	if (cc === CC_HYPHEN_MINUS) {
@@ -220,7 +273,7 @@ const consumeNumberSign = (input, pos, callbacks) => {
 	pos++;
 	if (pos === input.length) return pos;
 	if (callbacks.isSelector(input, pos) && _startsIdentifier(input, pos)) {
-		pos = _consumeIdentifier(input, pos);
+		pos = _consumeIdentifier(input, pos, callbacks);
 		if (callbacks.id !== undefined) {
 			return callbacks.id(input, start, pos);
 		}
@@ -244,7 +297,7 @@ const consumeMinus = (input, pos, callbacks) => {
 		if (cc === CC_GREATER_THAN_SIGN) {
 			return pos + 1;
 		} else {
-			pos = _consumeIdentifier(input, pos);
+			pos = _consumeIdentifier(input, pos, callbacks);
 			if (callbacks.identifier !== undefined) {
 				return callbacks.identifier(input, start, pos);
 			}
@@ -253,7 +306,7 @@ const consumeMinus = (input, pos, callbacks) => {
 		if (pos + 1 === input.length) return pos;
 		const cc = input.charCodeAt(pos + 1);
 		if (_isNewLine(cc)) return pos;
-		pos = _consumeIdentifier(input, pos);
+		pos = _consumeIdentifier(input, pos, callbacks);
 		if (callbacks.identifier !== undefined) {
 			return callbacks.identifier(input, start, pos);
 		}
@@ -272,16 +325,17 @@ const consumeDot = (input, pos, callbacks) => {
 	if (_isDigit(cc)) return consumeNumericToken(input, pos - 2, callbacks);
 	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
 		return pos;
-	pos = _consumeIdentifier(input, pos);
+	pos = _consumeIdentifier(input, pos, callbacks);
 	if (callbacks.class !== undefined) return callbacks.class(input, start, pos);
 	return pos;
 };
 
 /** @type {CharHandler} */
 const consumeNumericToken = (input, pos, callbacks) => {
-	pos = _consumeNumber(input, pos);
+	pos = _consumeNumber(input, pos, callbacks);
 	if (pos === input.length) return pos;
-	if (_startsIdentifier(input, pos)) return _consumeIdentifier(input, pos);
+	if (_startsIdentifier(input, pos))
+		return _consumeIdentifier(input, pos, callbacks);
 	const cc = input.charCodeAt(pos);
 	if (cc === CC_PERCENTAGE) return pos + 1;
 	return pos;
@@ -290,12 +344,8 @@ const consumeNumericToken = (input, pos, callbacks) => {
 /** @type {CharHandler} */
 const consumeOtherIdentifier = (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeIdentifier(input, pos);
-	if (
-		pos !== input.length &&
-		!callbacks.isSelector(input, pos) &&
-		input.charCodeAt(pos) === CC_LEFT_PARENTHESIS
-	) {
+	pos = _consumeIdentifier(input, pos, callbacks);
+	if (pos !== input.length && input.charCodeAt(pos) === CC_LEFT_PARENTHESIS) {
 		pos++;
 		if (callbacks.function !== undefined) {
 			return callbacks.function(input, start, pos);
@@ -311,7 +361,7 @@ const consumeOtherIdentifier = (input, pos, callbacks) => {
 /** @type {CharHandler} */
 const consumePotentialUrl = (input, pos, callbacks) => {
 	const start = pos;
-	pos = _consumeIdentifier(input, pos);
+	pos = _consumeIdentifier(input, pos, callbacks);
 	const nextPos = pos + 1;
 	if (
 		pos === start + 3 &&
@@ -331,6 +381,7 @@ const consumePotentialUrl = (input, pos, callbacks) => {
 			return nextPos;
 		} else {
 			const contentStart = pos;
+			/** @type {number} */
 			let contentEnd;
 			for (;;) {
 				if (cc === CC_REVERSE_SOLIDUS) {
@@ -380,7 +431,7 @@ const consumePotentialPseudo = (input, pos, callbacks) => {
 	pos++;
 	if (!callbacks.isSelector(input, pos) || !_startsIdentifier(input, pos))
 		return pos;
-	pos = _consumeIdentifier(input, pos);
+	pos = _consumeIdentifier(input, pos, callbacks);
 	let cc = input.charCodeAt(pos);
 	if (cc === CC_LEFT_PARENTHESIS) {
 		pos++;
@@ -449,6 +500,7 @@ const consumeComma = (input, pos, callbacks) => {
 	return pos;
 };
 
+/** @type {CharHandler} */
 const _consumeIdentifier = (input, pos) => {
 	for (;;) {
 		const cc = input.charCodeAt(pos);
@@ -468,6 +520,7 @@ const _consumeIdentifier = (input, pos) => {
 	}
 };
 
+/** @type {CharHandler} */
 const _consumeNumber = (input, pos) => {
 	pos++;
 	if (pos === input.length) return pos;
@@ -526,12 +579,13 @@ const consumeLessThan = (input, pos, callbacks) => {
 	return pos + 1;
 };
 
+/** @type {CharHandler} */
 const consumeAt = (input, pos, callbacks) => {
 	const start = pos;
 	pos++;
 	if (pos === input.length) return pos;
 	if (_startsIdentifier(input, pos)) {
-		pos = _consumeIdentifier(input, pos);
+		pos = _consumeIdentifier(input, pos, callbacks);
 		if (callbacks.atKeyword !== undefined) {
 			pos = callbacks.atKeyword(input, start, pos);
 		}
@@ -629,7 +683,7 @@ const CHAR_MAP = Array.from({ length: 0x80 }, (_, cc) => {
 			// digit
 			if (_isDigit(cc)) return consumeNumericToken;
 			// ident-start code point
-			if (_isIdentStartCodePoint(cc)) {
+			if (isIdentStartCodePoint(cc)) {
 				return consumeOtherIdentifier;
 			}
 			// EOF, but we don't have it
@@ -661,6 +715,8 @@ module.exports = (input, callbacks) => {
 	}
 };
 
+module.exports.isIdentStartCodePoint = isIdentStartCodePoint;
+
 /**
  * @param {string} input input
  * @param {number} pos position
@@ -678,6 +734,19 @@ module.exports.eatComments = (input, pos) => {
 	return pos;
 };
 
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {number} position after whitespace
+ */
+module.exports.eatWhitespace = (input, pos) => {
+	while (_isWhiteSpace(input.charCodeAt(pos))) {
+		pos++;
+	}
+
+	return pos;
+};
+
 /**
  * @param {string} input input
  * @param {number} pos position
@@ -697,3 +766,25 @@ module.exports.eatWhitespaceAndComments = (input, pos) => {
 
 	return pos;
 };
+
+/**
+ * @param {string} input input
+ * @param {number} pos position
+ * @returns {number} position after whitespace
+ */
+module.exports.eatWhiteLine = (input, pos) => {
+	for (;;) {
+		const cc = input.charCodeAt(pos);
+		if (_isSpace(cc)) {
+			pos++;
+			continue;
+		}
+		if (_isNewLine(cc)) pos++;
+		// For `\r\n`
+		if (cc === CC_CARRIAGE_RETURN && input.charCodeAt(pos + 1) === CC_LINE_FEED)
+			pos++;
+		break;
+	}
+
+	return pos;
+};

package/lib/debug/ProfilingPlugin.js

@@ -100,6 +100,8 @@ class Profiler {
 		return this.sendCommand("Profiler.stop").then(({ profile }) => {
 			const hrtime = process.hrtime();
 			const endTime = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000);
+			// Avoid coverage problems due indirect changes
+			/* istanbul ignore next */
 			if (profile.startTime < this._startTime || profile.endTime > endTime) {
 				// In some cases timestamps mismatch and we need to adjust them
 				// Both process.hrtime and the inspector timestamps claim to be relative

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -159,6 +159,7 @@ module.exports = class HarmonyImportDependencyParserPlugin {
 
 				const rootInfo = rightPart.rootInfo;
 				if (
+					typeof rootInfo === "string" ||
 					!rootInfo ||
 					!rootInfo.tagInfo ||
 					rootInfo.tagInfo.tag !== harmonySpecifierTag

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -127,7 +127,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			"",
 			"// object to store loaded and loading chunks",
 			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded",
+			"// [resolve, Promise] = chunk loading, 0 = chunk loaded",
 			`var installedChunks = ${
 				stateExpression ? `${stateExpression} = ${stateExpression} || ` : ""
 			}{`,
@@ -210,7 +210,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 													)})])`,
 													`promises.push(installedChunkData[1] = promise);`
 												]),
-												"} else installedChunks[chunkId] = 0;"
+												hasJsMatcher === true
+													? "}"
+													: "} else installedChunks[chunkId] = 0;"
 											]),
 											"}"
 										]),

package/lib/hmr/LazyCompilationPlugin.js

@@ -10,6 +10,9 @@ const AsyncDependenciesBlock = require("../AsyncDependenciesBlock");
 const Dependency = require("../Dependency");
 const Module = require("../Module");
 const ModuleFactory = require("../ModuleFactory");
+const {
+	WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY
+} = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDependency");
@@ -95,7 +98,11 @@ registerNotSerializable(LazyCompilationDependency);
 
 class LazyCompilationProxyModule extends Module {
 	constructor(context, originalModule, request, client, data, active) {
-		super("lazy-compilation-proxy", context, originalModule.layer);
+		super(
+			WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY,
+			context,
+			originalModule.layer
+		);
 		this.originalModule = originalModule;
 		this.request = request;
 		this.client = client;
@@ -107,7 +114,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
-		return `lazy-compilation-proxy|${this.originalModule.identifier()}`;
+		return `${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY}|${this.originalModule.identifier()}`;
 	}
 
 	/**
@@ -115,7 +122,7 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string} a user readable identifier of the module
 	 */
 	readableIdentifier(requestShortener) {
-		return `lazy-compilation-proxy ${this.originalModule.readableIdentifier(
+		return `${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY} ${this.originalModule.readableIdentifier(
 			requestShortener
 		)}`;
 	}
@@ -142,7 +149,9 @@ class LazyCompilationProxyModule extends Module {
 	 * @returns {string | null} an identifier for library inclusion
 	 */
 	libIdent(options) {
-		return `${this.originalModule.libIdent(options)}!lazy-compilation-proxy`;
+		return `${this.originalModule.libIdent(
+			options
+		)}!${WEBPACK_MODULE_TYPE_LAZY_COMPILATION_PROXY}`;
 	}
 
 	/**

package/lib/javascript/BasicEvaluatedExpression.js

@@ -60,10 +60,11 @@ class BasicEvaluatedExpression {
 		this.prefix = undefined;
 		/** @type {BasicEvaluatedExpression | undefined} */
 		this.postfix = undefined;
+		/** @type {BasicEvaluatedExpression[]} */
 		this.wrappedInnerExpressions = undefined;
 		/** @type {string | VariableInfoInterface | undefined} */
 		this.identifier = undefined;
-		/** @type {VariableInfoInterface} */
+		/** @type {string | VariableInfoInterface} */
 		this.rootInfo = undefined;
 		/** @type {() => string[]} */
 		this.getMembers = undefined;
@@ -222,6 +223,10 @@ class BasicEvaluatedExpression {
 		return this.sideEffects;
 	}
 
+	/**
+	 * Creates a boolean representation of this evaluated expression.
+	 * @returns {boolean | undefined} true: truthy, false: falsy, undefined: unknown
+	 */
 	asBool() {
 		if (this.truthy) return true;
 		if (this.falsy || this.nullish) return false;
@@ -247,6 +252,10 @@ class BasicEvaluatedExpression {
 		return undefined;
 	}
 
+	/**
+	 * Creates a nullish coalescing representation of this evaluated expression.
+	 * @returns {boolean | undefined} true: nullish, false: not nullish, undefined: unknown
+	 */
 	asNullish() {
 		const nullish = this.isNullish();
 
@@ -267,6 +276,10 @@ class BasicEvaluatedExpression {
 		return undefined;
 	}
 
+	/**
+	 * Creates a string representation of this evaluated expression.
+	 * @returns {string | undefined} the string representation or undefined if not possible
+	 */
 	asString() {
 		if (this.isBoolean()) return `${this.bool}`;
 		if (this.isNull()) return "null";
@@ -316,6 +329,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of this expression to a number
+	 * @param {number} number number to set
+	 * @returns {this} this
+	 */
 	setNumber(number) {
 		this.type = TypeNumber;
 		this.number = number;
@@ -323,6 +341,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of this expression to a BigInt
+	 * @param {bigint} bigint bigint to set
+	 * @returns {this} this
+	 */
 	setBigInt(bigint) {
 		this.type = TypeBigInt;
 		this.bigint = bigint;
@@ -330,6 +353,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of this expression to a boolean
+	 * @param {boolean} bool boolean to set
+	 * @returns {this} this
+	 */
 	setBoolean(bool) {
 		this.type = TypeBoolean;
 		this.bool = bool;
@@ -337,6 +365,11 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of this expression to a regular expression
+	 * @param {RegExp} regExp regular expression to set
+	 * @returns {this} this
+	 */
 	setRegExp(regExp) {
 		this.type = TypeRegExp;
 		this.regExp = regExp;
@@ -344,6 +377,15 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of this expression to a particular identifier and its members.
+	 *
+	 * @param {string | VariableInfoInterface} identifier identifier to set
+	 * @param {string | VariableInfoInterface} rootInfo root info
+	 * @param {() => string[]} getMembers members
+	 * @param {() => boolean[]=} getMembersOptionals optional members
+	 * @returns {this} this
+	 */
 	setIdentifier(identifier, rootInfo, getMembers, getMembersOptionals) {
 		this.type = TypeIdentifier;
 		this.identifier = identifier;
@@ -354,6 +396,14 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Wraps an array of expressions with a prefix and postfix expression.
+	 *
+	 * @param {BasicEvaluatedExpression | null} prefix Expression to be added before the innerExpressions
+	 * @param {BasicEvaluatedExpression} postfix Expression to be added after the innerExpressions
+	 * @param {BasicEvaluatedExpression[]} innerExpressions Expressions to be wrapped
+	 * @returns {this} this
+	 */
 	setWrapped(prefix, postfix, innerExpressions) {
 		this.type = TypeWrapped;
 		this.prefix = prefix;
@@ -363,6 +413,12 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Stores the options of a conditional expression.
+	 *
+	 * @param {BasicEvaluatedExpression[]} options optional (consequent/alternate) expressions to be set
+	 * @returns {this} this
+	 */
 	setOptions(options) {
 		this.type = TypeConditional;
 		this.options = options;
@@ -370,6 +426,12 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Adds options to a conditional expression.
+	 *
+	 * @param {BasicEvaluatedExpression[]} options optional (consequent/alternate) expressions to be added
+	 * @returns {this} this
+	 */
 	addOptions(options) {
 		if (!this.options) {
 			this.type = TypeConditional;
@@ -382,6 +444,12 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of this expression to an array of expressions.
+	 *
+	 * @param {BasicEvaluatedExpression[]} items expressions to set
+	 * @returns {this} this
+	 */
 	setItems(items) {
 		this.type = TypeArray;
 		this.items = items;
@@ -389,6 +457,12 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of this expression to an array of strings.
+	 *
+	 * @param {string[]} array array to set
+	 * @returns {this} this
+	 */
 	setArray(array) {
 		this.type = TypeConstArray;
 		this.array = array;
@@ -396,6 +470,15 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of this expression to a processed/unprocessed template string. Used
+	 * for evaluating TemplateLiteral expressions in the JavaScript Parser.
+	 *
+	 * @param {BasicEvaluatedExpression[]} quasis template string quasis
+	 * @param {BasicEvaluatedExpression[]} parts template string parts
+	 * @param {"cooked" | "raw"} kind template string kind
+	 * @returns {this} this
+	 */
 	setTemplateString(quasis, parts, kind) {
 		this.type = TypeTemplateString;
 		this.quasis = quasis;
@@ -418,6 +501,12 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the value of the expression to nullish.
+	 *
+	 * @param {boolean} value true, if the expression is nullish
+	 * @returns {this} this
+	 */
 	setNullish(value) {
 		this.nullish = value;
 
@@ -426,16 +515,34 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
+	/**
+	 * Set's the range for the expression.
+	 *
+	 * @param {[number, number]} range range to set
+	 * @returns {this} this
+	 */
 	setRange(range) {
 		this.range = range;
 		return this;
 	}
 
+	/**
+	 * Set whether or not the expression has side effects.
+	 *
+	 * @param {boolean} sideEffects true, if the expression has side effects
+	 * @returns {this} this
+	 */
 	setSideEffects(sideEffects = true) {
 		this.sideEffects = sideEffects;
 		return this;
 	}
 
+	/**
+	 * Set the expression node for the expression.
+	 *
+	 * @param {EsTreeNode} expression expression
+	 * @returns {this} this
+	 */
 	setExpression(expression) {
 		this.expression = expression;
 		return this;

package/lib/javascript/JavascriptModulesPlugin.js

@@ -21,7 +21,8 @@ const InitFragment = require("../InitFragment");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
 	JAVASCRIPT_MODULE_TYPE_DYNAMIC,
-	JAVASCRIPT_MODULE_TYPE_ESM
+	JAVASCRIPT_MODULE_TYPE_ESM,
+	WEBPACK_MODULE_TYPE_RUNTIME
 } = require("../ModuleTypeConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
@@ -394,7 +395,7 @@ class JavascriptModulesPlugin {
 					}
 					const runtimeModules = chunkGraph.getChunkModulesIterableBySourceType(
 						chunk,
-						"runtime"
+						WEBPACK_MODULE_TYPE_RUNTIME
 					);
 					if (runtimeModules) {
 						const xor = new StringXor();