webpack 5.93.0 → 5.95.0

package/lib/rules/ObjectMatcherRulePlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").RuleCondition} RuleCondition */
 /** @typedef {import("./RuleSetCompiler").RuleConditionFunction} RuleConditionFunction */
@@ -32,7 +33,9 @@ class ObjectMatcherRulePlugin {
 			(path, rule, unhandledProperties, result) => {
 				if (unhandledProperties.has(ruleProperty)) {
 					unhandledProperties.delete(ruleProperty);
-					const value = rule[ruleProperty];
+					const value =
+						/** @type {Record<string, any>} */
+						(rule[/** @type {keyof RuleSetRule} */ (ruleProperty)]);
 					for (const property of Object.keys(value)) {
 						const nestedDataProperties = property.split(".");
 						const condition = ruleSetCompiler.compileCondition(

package/lib/rules/RuleSetCompiler.js

@@ -7,6 +7,9 @@
 
 const { SyncHook } = require("tapable");
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
+
 /** @typedef {function(string): boolean} RuleConditionFunction */
 
 /**
@@ -22,10 +25,14 @@ const { SyncHook } = require("tapable");
  * @property {RuleConditionFunction} fn
  */
 
+/**
+ * @typedef {Record<string, TODO>} EffectData
+ */
+
 /**
  * @typedef {object} CompiledRule
  * @property {RuleCondition[]} conditions
- * @property {(Effect|function(object): Effect[])[]} effects
+ * @property {(Effect|function(EffectData): Effect[])[]} effects
  * @property {CompiledRule[]=} rules
  * @property {CompiledRule[]=} oneOf
  */
@@ -39,13 +46,18 @@ const { SyncHook } = require("tapable");
 /**
  * @typedef {object} RuleSet
  * @property {Map<string, any>} references map of references in the rule set (may grow over time)
- * @property {function(object): Effect[]} exec execute the rule set
+ * @property {function(EffectData): Effect[]} exec execute the rule set
  */
 
+/** @typedef {{ apply: (function(RuleSetCompiler): void) }} RuleSetPlugin */
+
 class RuleSetCompiler {
+	/**
+	 * @param {RuleSetPlugin[]} plugins plugins
+	 */
 	constructor(plugins) {
 		this.hooks = Object.freeze({
-			/** @type {SyncHook<[string, object, Set<string>, CompiledRule, Map<string, any>]>} */
+			/** @type {SyncHook<[string, RuleSetRule, Set<string>, CompiledRule, Map<string | undefined, any>]>} */
 			rule: new SyncHook([
 				"path",
 				"rule",
@@ -62,7 +74,7 @@ class RuleSetCompiler {
 	}
 
 	/**
-	 * @param {object[]} ruleSet raw user provided rules
+	 * @param {TODO[]} ruleSet raw user provided rules
 	 * @returns {RuleSet} compiled RuleSet
 	 */
 	compile(ruleSet) {
@@ -70,7 +82,7 @@ class RuleSetCompiler {
 		const rules = this.compileRules("ruleSet", ruleSet, refs);
 
 		/**
-		 * @param {object} data data passed in
+		 * @param {EffectData} data data passed in
 		 * @param {CompiledRule} rule the compiled rule
 		 * @param {Effect[]} effects an array where effects are pushed to
 		 * @returns {boolean} true, if the rule has matched
@@ -79,6 +91,7 @@ class RuleSetCompiler {
 			for (const condition of rule.conditions) {
 				const p = condition.property;
 				if (Array.isArray(p)) {
+					/** @type {EffectData | string | undefined} */
 					let current = data;
 					for (const subProperty of p) {
 						if (
@@ -93,7 +106,7 @@ class RuleSetCompiler {
 						}
 					}
 					if (current !== undefined) {
-						if (!condition.fn(current)) return false;
+						if (!condition.fn(/** @type {string} */ (current))) return false;
 						continue;
 					}
 				} else if (p in data) {
@@ -147,25 +160,33 @@ class RuleSetCompiler {
 
 	/**
 	 * @param {string} path current path
-	 * @param {object[]} rules the raw rules provided by user
+	 * @param {RuleSetRules} rules the raw rules provided by user
 	 * @param {Map<string, any>} refs references
 	 * @returns {CompiledRule[]} rules
 	 */
 	compileRules(path, rules, refs) {
 		return rules
 			.filter(Boolean)
-			.map((rule, i) => this.compileRule(`${path}[${i}]`, rule, refs));
+			.map((rule, i) =>
+				this.compileRule(
+					`${path}[${i}]`,
+					/** @type {RuleSetRule} */ (rule),
+					refs
+				)
+			);
 	}
 
 	/**
 	 * @param {string} path current path
-	 * @param {object} rule the raw rule provided by user
+	 * @param {RuleSetRule} rule the raw rule provided by user
 	 * @param {Map<string, any>} refs references
 	 * @returns {CompiledRule} normalized and compiled rule for processing
 	 */
 	compileRule(path, rule, refs) {
 		const unhandledProperties = new Set(
-			Object.keys(rule).filter(key => rule[key] !== undefined)
+			Object.keys(rule).filter(
+				key => rule[/** @type {keyof RuleSetRule} */ (key)] !== undefined
+			)
 		);
 
 		/** @type {CompiledRule} */
@@ -236,7 +257,7 @@ class RuleSetCompiler {
 					matchWhenEmpty: condition(""),
 					fn: condition
 				};
-			} catch (err) {
+			} catch (_err) {
 				throw this.error(
 					path,
 					condition,
@@ -303,7 +324,7 @@ class RuleSetCompiler {
 						const fn = matcher.fn;
 						conditions.push({
 							matchWhenEmpty: !matcher.matchWhenEmpty,
-							fn: v => !fn(v)
+							fn: /** @type {RuleConditionFunction} */ (v => !fn(v))
 						});
 					}
 					break;
@@ -337,12 +358,11 @@ class RuleSetCompiler {
 			};
 		} else if (conditions.length === 1) {
 			return conditions[0];
-		} else {
-			return {
-				matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
-				fn: v => conditions.some(c => c.fn(v))
-			};
 		}
+		return {
+			matchWhenEmpty: conditions.some(c => c.matchWhenEmpty),
+			fn: v => conditions.some(c => c.fn(v))
+		};
 	}
 
 	/**
@@ -357,12 +377,11 @@ class RuleSetCompiler {
 			};
 		} else if (conditions.length === 1) {
 			return conditions[0];
-		} else {
-			return {
-				matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
-				fn: v => conditions.every(c => c.fn(v))
-			};
 		}
+		return {
+			matchWhenEmpty: conditions.every(c => c.matchWhenEmpty),
+			fn: v => conditions.every(c => c.fn(v))
+		};
 	}
 
 	/**

package/lib/rules/UseEffectRulePlugin.js

@@ -7,6 +7,9 @@
 
 const util = require("util");
 
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoader} RuleSetLoader */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetLoaderOptions} RuleSetLoaderOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
 
@@ -19,6 +22,10 @@ class UseEffectRulePlugin {
 		ruleSetCompiler.hooks.rule.tap(
 			"UseEffectRulePlugin",
 			(path, rule, unhandledProperties, result, references) => {
+				/**
+				 * @param {keyof RuleSetRule} property property
+				 * @param {string} correctProperty correct property
+				 */
 				const conflictWith = (property, correctProperty) => {
 					if (unhandledProperties.has(property)) {
 						throw ruleSetCompiler.error(
@@ -42,7 +49,6 @@ class UseEffectRulePlugin {
 					const type = enforce ? `use-${enforce}` : "use";
 
 					/**
-					 *
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
 					 * @param {object} item user provided use value
@@ -51,16 +57,14 @@ class UseEffectRulePlugin {
 					const useToEffect = (path, defaultIdent, item) => {
 						if (typeof item === "function") {
 							return data => useToEffectsWithoutIdent(path, item(data));
-						} else {
-							return useToEffectRaw(path, defaultIdent, item);
 						}
+						return useToEffectRaw(path, defaultIdent, item);
 					};
 
 					/**
-					 *
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {object} item user provided use value
+					 * @param {{ ident?: string, loader?: RuleSetLoader, options?: RuleSetLoaderOptions }} item user provided use value
 					 * @returns {Effect} effect
 					 */
 					const useToEffectRaw = (path, defaultIdent, item) => {
@@ -73,30 +77,29 @@ class UseEffectRulePlugin {
 									ident: undefined
 								}
 							};
-						} else {
-							const loader = item.loader;
-							const options = item.options;
-							let ident = item.ident;
-							if (options && typeof options === "object") {
-								if (!ident) ident = defaultIdent;
-								references.set(ident, options);
-							}
-							if (typeof options === "string") {
-								util.deprecate(
-									() => {},
-									`Using a string as loader options is deprecated (${path}.options)`,
-									"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
-								)();
-							}
-							return {
-								type: enforce ? `use-${enforce}` : "use",
-								value: {
-									loader,
-									options,
-									ident
-								}
-							};
 						}
+						const loader = item.loader;
+						const options = item.options;
+						let ident = item.ident;
+						if (options && typeof options === "object") {
+							if (!ident) ident = defaultIdent;
+							references.set(ident, options);
+						}
+						if (typeof options === "string") {
+							util.deprecate(
+								() => {},
+								`Using a string as loader options is deprecated (${path}.options)`,
+								"DEP_WEBPACK_RULE_LOADER_OPTIONS_STRING"
+							)();
+						}
+						return {
+							type: enforce ? `use-${enforce}` : "use",
+							value: {
+								loader,
+								options,
+								ident
+							}
+						};
 					};
 
 					/**
@@ -132,7 +135,10 @@ class UseEffectRulePlugin {
 
 					if (typeof use === "function") {
 						result.effects.push(data =>
-							useToEffectsWithoutIdent(`${path}.use`, use(data))
+							useToEffectsWithoutIdent(
+								`${path}.use`,
+								use(/** @type {TODO} */ (data))
+							)
 						);
 					} else {
 						for (const effect of useToEffects(`${path}.use`, use)) {
@@ -146,7 +152,7 @@ class UseEffectRulePlugin {
 					unhandledProperties.delete("options");
 					unhandledProperties.delete("enforce");
 
-					const loader = rule.loader;
+					const loader = /** @type {RuleSetLoader} */ (rule.loader);
 					const options = rule.options;
 					const enforce = rule.enforce;
 
@@ -189,8 +195,6 @@ class UseEffectRulePlugin {
 			}
 		);
 	}
-
-	useItemToEffects(path, item) {}
 }
 
 module.exports = UseEffectRulePlugin;

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -59,7 +59,7 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 							])});`,
 							"var obj = {};",
 							`obj[webpackQueues] = ${runtimeTemplate.expressionFunction(
-								`fn(queue)`,
+								"fn(queue)",
 								"fn"
 							)};`,
 							"return obj;"

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -10,6 +10,7 @@ const Template = require("../Template");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
 const { getUndoPath } = require("../util/identifier");
 
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
 
 class AutoPublicPathRuntimeModule extends RuntimeModule {
@@ -25,7 +26,8 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 		const { scriptType, importMetaName, path } = compilation.outputOptions;
 		const chunkName = compilation.getPath(
 			JavascriptModulesPlugin.getChunkFilenameTemplate(
-				this.chunk,
+				/** @type {Chunk} */
+				(this.chunk),
 				compilation.outputOptions
 			),
 			{
@@ -48,8 +50,11 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 						`var document = ${RuntimeGlobals.global}.document;`,
 						"if (!scriptUrl && document) {",
 						Template.indent([
-							`if (document.currentScript)`,
-							Template.indent(`scriptUrl = document.currentScript.src;`),
+							// Technically we could use `document.currentScript instanceof window.HTMLScriptElement`,
+							// but an attacker could try to inject `<script>HTMLScriptElement = HTMLImageElement</script>`
+							// and use `<img name="currentScript" src="https://attacker.controlled.server/"></img>`
+							"if (document.currentScript && document.currentScript.tagName.toUpperCase() === 'SCRIPT')",
+							Template.indent("scriptUrl = document.currentScript.src;"),
 							"if (!scriptUrl) {",
 							Template.indent([
 								'var scripts = document.getElementsByTagName("script");',

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -37,8 +37,8 @@ class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 			// Note: must be a function (not arrow), because this is used in body!
 			`${fn} = function(value, mode) {`,
 			Template.indent([
-				`if(mode & 1) value = this(value);`,
-				`if(mode & 8) return value;`,
+				"if(mode & 1) value = this(value);",
+				"if(mode & 8) return value;",
 				"if(typeof value === 'object' && value) {",
 				Template.indent([
 					"if((mode & 4) && value.__esModule) return value;",

package/lib/runtime/DefinePropertyGettersRuntimeModule.js

@@ -25,7 +25,7 @@ class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
 		return Template.asString([
 			"// define getter functions for harmony exports",
 			`${fn} = ${runtimeTemplate.basicFunction("exports, definition", [
-				`for(var key in definition) {`,
+				"for(var key in definition) {",
 				Template.indent([
 					`if(${RuntimeGlobals.hasOwnProperty}(definition, key) && !${RuntimeGlobals.hasOwnProperty}(exports, key)) {`,
 					Template.indent([

package/lib/runtime/EnsureChunkRuntimeModule.js

@@ -51,18 +51,17 @@ class EnsureChunkRuntimeModule extends RuntimeModule {
 					]
 				)};`
 			]);
-		} else {
-			// There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure
-			// function. This can happen with multiple entrypoints.
-			return Template.asString([
-				"// The chunk loading function for additional chunks",
-				"// Since all referenced chunks are already included",
-				"// in this file, this function is empty here.",
-				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.returningFunction(
-					"Promise.resolve()"
-				)};`
-			]);
 		}
+		// There ensureChunk is used somewhere in the tree, so we need an empty requireEnsure
+		// function. This can happen with multiple entrypoints.
+		return Template.asString([
+			"// The chunk loading function for additional chunks",
+			"// Since all referenced chunks are already included",
+			"// in this file, this function is empty here.",
+			`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.returningFunction(
+				"Promise.resolve()"
+			)};`
+		]);
 	}
 }
 

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -13,16 +13,14 @@ const { first } = require("../util/SetHelpers");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
-/** @typedef {import("../Compilation").PathData} PathData */
-
-/** @typedef {function(PathData, AssetInfo=): string} FilenameFunction */
+/** @typedef {import("../TemplatedPathPlugin").TemplatePath} TemplatePath */
 
 class GetChunkFilenameRuntimeModule extends RuntimeModule {
 	/**
 	 * @param {string} contentType the contentType to use the content hash for
 	 * @param {string} name kind of filename
 	 * @param {string} global function name to be assigned
-	 * @param {function(Chunk): string | FilenameFunction} getFilenameForChunk functor to get the filename or function
+	 * @param {function(Chunk): TemplatePath} getFilenameForChunk functor to get the filename or function
 	 * @param {boolean} allChunks when false, only async chunks are included
 	 */
 	constructor(contentType, name, global, getFilenameForChunk, allChunks) {
@@ -44,7 +42,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const { runtimeTemplate } = compilation;
 
-		/** @type {Map<string | FilenameFunction, Set<Chunk>>} */
+		/** @type {Map<string | TemplatePath, Set<Chunk>>} */
 		const chunkFilenames = new Map();
 		let maxChunks = 0;
 		/** @type {string | undefined} */
@@ -74,11 +72,10 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 
 						if (
 							chunkFilename.length ===
-							/** @type {string} */ (dynamicFilename).length
+								/** @type {string} */ (dynamicFilename).length &&
+							chunkFilename < /** @type {string} */ (dynamicFilename)
 						) {
-							if (chunkFilename < /** @type {string} */ (dynamicFilename)) {
-								return;
-							}
+							return;
 						}
 					}
 					maxChunks = set.size;
@@ -122,7 +119,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 
 		/**
 		 * @param {Chunk} c the chunk
-		 * @param {string | FilenameFunction} chunkFilename the filename template for the chunk
+		 * @param {string | TemplatePath} chunkFilename the filename template for the chunk
 		 * @returns {void}
 		 */
 		const addStaticUrl = (c, chunkFilename) => {
@@ -137,7 +134,7 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 					return '" + chunkId + "';
 				}
 				const s = JSON.stringify(str);
-				return s.slice(1, s.length - 1);
+				return s.slice(1, -1);
 			};
 			/**
 			 * @param {string} value string
@@ -231,17 +228,14 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 		 * @param {function(Chunk): string | number} fn function from chunk to value
 		 * @returns {string} code with static mapping of results of fn for including in quoted string
 		 */
-		const mapExpr = fn => {
-			return `" + ${createMap(fn)} + "`;
-		};
+		const mapExpr = fn => `" + ${createMap(fn)} + "`;
 
 		/**
 		 * @param {function(Chunk): string | number} fn function from chunk to value
 		 * @returns {function(number): string} function which generates code with static mapping of results of fn for including in quoted string for specific length
 		 */
-		const mapExprWithLength = fn => length => {
-			return `" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
-		};
+		const mapExprWithLength = fn => length =>
+			`" + ${createMap(c => `${fn(c)}`.slice(0, length))} + "`;
 
 		const url =
 			dynamicFilename &&

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -113,7 +113,7 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 		return Template.asString([
 			"var inProgress = {};",
 			uniqueName
-				? `var dataWebpackPrefix = ${JSON.stringify(uniqueName + ":")};`
+				? `var dataWebpackPrefix = ${JSON.stringify(`${uniqueName}:`)};`
 				: "// data-webpack is not used as build has no uniqueName",
 			"// loadScript function to load a script via script tag",
 			`${fn} = ${runtimeTemplate.basicFunction(
@@ -145,23 +145,22 @@ class LoadScriptRuntimeModule extends HelperRuntimeModule {
 					]),
 					"}",
 					"inProgress[url] = [done];",
-					"var onScriptComplete = " +
-						runtimeTemplate.basicFunction(
-							"prev, event",
-							Template.asString([
-								"// avoid mem leaks in IE.",
-								"script.onerror = script.onload = null;",
-								"clearTimeout(timeout);",
-								"var doneFns = inProgress[url];",
-								"delete inProgress[url];",
-								"script.parentNode && script.parentNode.removeChild(script);",
-								`doneFns && doneFns.forEach(${runtimeTemplate.returningFunction(
-									"fn(event)",
-									"fn"
-								)});`,
-								"if(prev) return prev(event);"
-							])
-						),
+					`var onScriptComplete = ${runtimeTemplate.basicFunction(
+						"prev, event",
+						Template.asString([
+							"// avoid mem leaks in IE.",
+							"script.onerror = script.onload = null;",
+							"clearTimeout(timeout);",
+							"var doneFns = inProgress[url];",
+							"delete inProgress[url];",
+							"script.parentNode && script.parentNode.removeChild(script);",
+							`doneFns && doneFns.forEach(${runtimeTemplate.returningFunction(
+								"fn(event)",
+								"fn"
+							)});`,
+							"if(prev) return prev(event);"
+						])
+					)}`,
 					`var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), ${loadTimeout});`,
 					"script.onerror = onScriptComplete.bind(null, script.onerror);",
 					"script.onload = onScriptComplete.bind(null, script.onload);",

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -30,9 +30,7 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 		const chunk = /** @type {Chunk} */ (this.chunk);
 		const chunkIds = Array.from(
 			chunkGraph.getChunkEntryDependentChunksIterable(chunk)
-		).map(chunk => {
-			return chunk.id;
-		});
+		).map(chunk => chunk.id);
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
 		return Template.asString([

package/lib/schemes/DataUriPlugin.js

@@ -15,7 +15,7 @@ const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64))?,(.*)$/i;
 
 /**
  * @param {string} uri data URI
- * @returns {Buffer|null} decoded data
+ * @returns {Buffer | null} decoded data
  */
 const decodeDataURI = uri => {
 	const match = URIRegEx.exec(uri);