webpack 5.76.1 → 5.88.0

package/lib/javascript/BasicEvaluatedExpression.js

@@ -5,7 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("estree").Node} EsTreeNode */
+/** @typedef {import("estree").Node} Node */
+/** @typedef {import("./JavascriptParser").Range} Range */
 /** @typedef {import("./JavascriptParser").VariableInfoInterface} VariableInfoInterface */
 
 const TypeUnknown = 0;
@@ -26,7 +27,7 @@ const TypeBigInt = 13;
 class BasicEvaluatedExpression {
 	constructor() {
 		this.type = TypeUnknown;
-		/** @type {[number, number]} */
+		/** @type {[number, number] | undefined} */
 		this.range = undefined;
 		/** @type {boolean} */
 		this.falsy = false;
@@ -56,20 +57,23 @@ class BasicEvaluatedExpression {
 		this.items = undefined;
 		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.options = undefined;
-		/** @type {BasicEvaluatedExpression | undefined} */
+		/** @type {BasicEvaluatedExpression | undefined | null} */
 		this.prefix = undefined;
-		/** @type {BasicEvaluatedExpression | undefined} */
+		/** @type {BasicEvaluatedExpression | undefined | null} */
 		this.postfix = undefined;
+		/** @type {BasicEvaluatedExpression[] | undefined} */
 		this.wrappedInnerExpressions = undefined;
 		/** @type {string | VariableInfoInterface | undefined} */
 		this.identifier = undefined;
-		/** @type {VariableInfoInterface} */
+		/** @type {string | VariableInfoInterface | undefined} */
 		this.rootInfo = undefined;
-		/** @type {() => string[]} */
+		/** @type {(() => string[]) | undefined} */
 		this.getMembers = undefined;
-		/** @type {() => boolean[]} */
+		/** @type {(() => boolean[]) | undefined} */
 		this.getMembersOptionals = undefined;
-		/** @type {EsTreeNode} */
+		/** @type {(() => Range[]) | undefined} */
+		this.getMemberRanges = undefined;
+		/** @type {Node | undefined} */
 		this.expression = undefined;
 	}
 
@@ -222,6 +226,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 +255,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 +279,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";
@@ -277,7 +293,9 @@ class BasicEvaluatedExpression {
 		if (this.isRegExp()) return `${this.regExp}`;
 		if (this.isArray()) {
 			let array = [];
-			for (const item of this.items) {
+			for (const item of /** @type {BasicEvaluatedExpression[]} */ (
+				this.items
+			)) {
 				const itemStr = item.asString();
 				if (itemStr === undefined) return undefined;
 				array.push(itemStr);
@@ -287,7 +305,9 @@ class BasicEvaluatedExpression {
 		if (this.isConstArray()) return `${this.array}`;
 		if (this.isTemplateString()) {
 			let str = "";
-			for (const part of this.parts) {
+			for (const part of /** @type {BasicEvaluatedExpression[]} */ (
+				this.parts
+			)) {
 				const partStr = part.asString();
 				if (partStr === undefined) return undefined;
 				str += partStr;
@@ -297,6 +317,10 @@ class BasicEvaluatedExpression {
 		return undefined;
 	}
 
+	/**
+	 * @param {string} string value
+	 * @returns {BasicEvaluatedExpression} basic evaluated expression
+	 */
 	setString(string) {
 		this.type = TypeString;
 		this.string = string;
@@ -316,6 +340,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 +352,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 +364,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 +376,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,16 +388,41 @@ class BasicEvaluatedExpression {
 		return this;
 	}
 
-	setIdentifier(identifier, rootInfo, getMembers, getMembersOptionals) {
+	/**
+	 * 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
+	 * @param {() => Range[]=} getMemberRanges ranges of progressively increasing sub-expressions
+	 * @returns {this} this
+	 */
+	setIdentifier(
+		identifier,
+		rootInfo,
+		getMembers,
+		getMembersOptionals,
+		getMemberRanges
+	) {
 		this.type = TypeIdentifier;
 		this.identifier = identifier;
 		this.rootInfo = rootInfo;
 		this.getMembers = getMembers;
 		this.getMembersOptionals = getMembersOptionals;
+		this.getMemberRanges = getMemberRanges;
 		this.sideEffects = true;
 		return this;
 	}
 
+	/**
+	 * Wraps an array of expressions with a prefix and postfix expression.
+	 *
+	 * @param {BasicEvaluatedExpression | null | undefined} prefix Expression to be added before the innerExpressions
+	 * @param {BasicEvaluatedExpression | null | undefined} 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 +432,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 +445,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 +463,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 +476,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 +489,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 +520,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 +534,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 {Node | undefined} expression expression
+	 * @returns {this} this
+	 */
 	setExpression(expression) {
 		this.expression = expression;
 		return this;

package/lib/javascript/ChunkHelpers.js

@@ -11,8 +11,8 @@ const Entrypoint = require("../Entrypoint");
 
 /**
  * @param {Entrypoint} entrypoint a chunk group
- * @param {Chunk} excludedChunk1 current chunk which is excluded
- * @param {Chunk} excludedChunk2 runtime chunk which is excluded
+ * @param {Chunk=} excludedChunk1 current chunk which is excluded
+ * @param {Chunk=} excludedChunk2 runtime chunk which is excluded
  * @returns {Set<Chunk>} chunks
  */
 const getAllChunks = (entrypoint, excludedChunk1, excludedChunk2) => {

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -17,7 +17,9 @@ const {
 	updateHashForEntryStartup
 } = require("./StartupHelpers");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../Entrypoint")} Entrypoint */
 
 class CommonJsChunkFormatPlugin {
 	/**
@@ -66,7 +68,9 @@ class CommonJsChunkFormatPlugin {
 							chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)
 						);
 						if (entries.length > 0) {
-							const runtimeChunk = entries[0][1].getRuntimeChunk();
+							const runtimeChunk =
+								/** @type {Entrypoint} */
+								(entries[0][1]).getRuntimeChunk();
 							const currentOutputName = compilation
 								.getPath(
 									getChunkFilenameTemplate(chunk, compilation.outputOptions),
@@ -83,7 +87,7 @@ class CommonJsChunkFormatPlugin {
 										compilation.outputOptions
 									),
 									{
-										chunk: runtimeChunk,
+										chunk: /** @type {Chunk} */ (runtimeChunk),
 										contentHashType: "javascript"
 									}
 								)
@@ -120,7 +124,7 @@ class CommonJsChunkFormatPlugin {
 							entrySource.add(source);
 							entrySource.add(";\n\n// load runtime\n");
 							entrySource.add(
-								`var __webpack_require__ = require(${JSON.stringify(
+								`var ${RuntimeGlobals.require} = require(${JSON.stringify(
 									runtimePath
 								)});\n`
 							);

package/lib/javascript/EnableChunkLoadingPlugin.js

@@ -11,6 +11,10 @@
 /** @type {WeakMap<Compiler, Set<ChunkLoadingType>>} */
 const enabledTypes = new WeakMap();
 
+/**
+ * @param {Compiler} compiler compiler
+ * @returns {Set<ChunkLoadingType>} enabled types
+ */
 const getEnabledTypes = compiler => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {