webpack 5.81.0 → 5.82.0

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/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/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
+													)}');`
+												]),
+												"}"
+										  ]
+										: [])
 								]),
 								"}"
 						  ]