webpack 5.59.0 → 5.94.0

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -8,23 +8,28 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("async module");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.asyncModule;
 		return Template.asString([
-			'var webpackThen = typeof Symbol === "function" ? Symbol("webpack then") : "__webpack_then__";',
-			'var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "__webpack_exports__";',
-			`var completeQueue = ${runtimeTemplate.basicFunction("queue", [
-				"if(queue) {",
+			'var webpackQueues = typeof Symbol === "function" ? Symbol("webpack queues") : "__webpack_queues__";',
+			`var webpackExports = typeof Symbol === "function" ? Symbol("webpack exports") : "${RuntimeGlobals.exports}";`,
+			'var webpackError = typeof Symbol === "function" ? Symbol("webpack error") : "__webpack_error__";',
+			`var resolveQueue = ${runtimeTemplate.basicFunction("queue", [
+				"if(queue && queue.d < 1) {",
 				Template.indent([
+					"queue.d = 1;",
 					`queue.forEach(${runtimeTemplate.expressionFunction(
 						"fn.r--",
 						"fn"
@@ -36,108 +41,90 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 				]),
 				"}"
 			])}`,
-			`var completeFunction = ${runtimeTemplate.expressionFunction(
-				"!--fn.r && fn()",
-				"fn"
-			)};`,
-			`var queueFunction = ${runtimeTemplate.expressionFunction(
-				"queue ? queue.push(fn) : completeFunction(fn)",
-				"queue, fn"
-			)};`,
 			`var wrapDeps = ${runtimeTemplate.returningFunction(
 				`deps.map(${runtimeTemplate.basicFunction("dep", [
 					'if(dep !== null && typeof dep === "object") {',
 					Template.indent([
-						"if(dep[webpackThen]) return dep;",
+						"if(dep[webpackQueues]) return dep;",
 						"if(dep.then) {",
 						Template.indent([
 							"var queue = [];",
+							"queue.d = 0;",
 							`dep.then(${runtimeTemplate.basicFunction("r", [
 								"obj[webpackExports] = r;",
-								"completeQueue(queue);",
-								"queue = 0;"
+								"resolveQueue(queue);"
+							])}, ${runtimeTemplate.basicFunction("e", [
+								"obj[webpackError] = e;",
+								"resolveQueue(queue);"
 							])});`,
-							`var obj = {};
-							obj[webpackThen] = ${runtimeTemplate.expressionFunction(
-								"queueFunction(queue, fn), dep.catch(reject)",
-								"fn, reject"
+							"var obj = {};",
+							`obj[webpackQueues] = ${runtimeTemplate.expressionFunction(
+								"fn(queue)",
+								"fn"
 							)};`,
 							"return obj;"
 						]),
 						"}"
 					]),
 					"}",
-					`var ret = {};
-					ret[webpackThen] = ${runtimeTemplate.expressionFunction(
-						"completeFunction(fn)",
-						"fn"
-					)};
-					ret[webpackExports] = dep;
-					return ret;`
+					"var ret = {};",
+					`ret[webpackQueues] = ${runtimeTemplate.emptyFunction()};`,
+					"ret[webpackExports] = dep;",
+					"return ret;"
 				])})`,
 				"deps"
 			)};`,
 			`${fn} = ${runtimeTemplate.basicFunction("module, body, hasAwait", [
-				"var queue = hasAwait && [];",
+				"var queue;",
+				"hasAwait && ((queue = []).d = -1);",
+				"var depQueues = new Set();",
 				"var exports = module.exports;",
 				"var currentDeps;",
 				"var outerResolve;",
 				"var reject;",
-				"var isEvaluating = true;",
-				"var nested = false;",
-				`var whenAll = ${runtimeTemplate.basicFunction(
-					"deps, onResolve, onReject",
-					[
-						"if (nested) return;",
-						"nested = true;",
-						"onResolve.r += deps.length;",
-						`deps.map(${runtimeTemplate.expressionFunction(
-							"dep[webpackThen](onResolve, onReject)",
-							"dep, i"
-						)});`,
-						"nested = false;"
-					]
-				)};`,
 				`var promise = new Promise(${runtimeTemplate.basicFunction(
 					"resolve, rej",
-					[
-						"reject = rej;",
-						`outerResolve = ${runtimeTemplate.expressionFunction(
-							"resolve(exports), completeQueue(queue), queue = 0"
-						)};`
-					]
+					["reject = rej;", "outerResolve = resolve;"]
 				)});`,
 				"promise[webpackExports] = exports;",
-				`promise[webpackThen] = ${runtimeTemplate.basicFunction(
-					"fn, rejectFn",
-					[
-						"if (isEvaluating) { return completeFunction(fn); }",
-						"if (currentDeps) whenAll(currentDeps, fn, rejectFn);",
-						"queueFunction(queue, fn);",
-						"promise.catch(rejectFn);"
-					]
+				`promise[webpackQueues] = ${runtimeTemplate.expressionFunction(
+					`queue && fn(queue), depQueues.forEach(fn), promise["catch"](${runtimeTemplate.emptyFunction()})`,
+					"fn"
 				)};`,
 				"module.exports = promise;",
 				`body(${runtimeTemplate.basicFunction("deps", [
-					"if(!deps) return outerResolve();",
 					"currentDeps = wrapDeps(deps);",
-					"var fn, result;",
+					"var fn;",
+					`var getResult = ${runtimeTemplate.returningFunction(
+						`currentDeps.map(${runtimeTemplate.basicFunction("d", [
+							"if(d[webpackError]) throw d[webpackError];",
+							"return d[webpackExports];"
+						])})`
+					)}`,
 					`var promise = new Promise(${runtimeTemplate.basicFunction(
-						"resolve, reject",
+						"resolve",
 						[
 							`fn = ${runtimeTemplate.expressionFunction(
-								`resolve(result = currentDeps.map(${runtimeTemplate.returningFunction(
-									"d[webpackExports]",
-									"d"
-								)}))`
+								"resolve(getResult)",
+								""
 							)};`,
 							"fn.r = 0;",
-							"whenAll(currentDeps, fn, reject);"
+							`var fnQueue = ${runtimeTemplate.expressionFunction(
+								"q !== queue && !depQueues.has(q) && (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)))",
+								"q"
+							)};`,
+							`currentDeps.map(${runtimeTemplate.expressionFunction(
+								"dep[webpackQueues](fnQueue)",
+								"dep"
+							)});`
 						]
 					)});`,
-					"return fn.r ? promise : result;"
-				])}).then(outerResolve, reject);`,
-				"isEvaluating = false;"
+					"return fn.r ? promise : getResult();"
+				])}, ${runtimeTemplate.expressionFunction(
+					"(err ? reject(promise[webpackError] = err) : outerResolve(exports)), resolveQueue(queue)",
+					"err"
+				)});`,
+				"queue && queue.d < 0 && (queue.d = 0);"
 			])};`
 		]);
 	}

package/lib/runtime/AutoPublicPathRuntimeModule.js

@@ -10,20 +10,24 @@ 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 {
 	constructor() {
 		super("publicPath", RuntimeModule.STAGE_BASIC);
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { scriptType, importMetaName, path } = compilation.outputOptions;
 		const chunkName = compilation.getPath(
 			JavascriptModulesPlugin.getChunkFilenameTemplate(
-				this.chunk,
+				/** @type {Chunk} */
+				(this.chunk),
 				compilation.outputOptions
 			),
 			{
@@ -31,7 +35,11 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 				contentHashType: "javascript"
 			}
 		);
-		const undoPath = getUndoPath(chunkName, path, false);
+		const undoPath = getUndoPath(
+			chunkName,
+			/** @type {string} */ (path),
+			false
+		);
 
 		return Template.asString([
 			"var scriptUrl;",
@@ -42,17 +50,25 @@ 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");',
-								"if(scripts.length) scriptUrl = scripts[scripts.length - 1].src"
+								"if(scripts.length) {",
+								Template.indent([
+									"var i = scripts.length - 1;",
+									"while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;"
+								]),
+								"}"
 							]),
 							"}"
 						]),
 						"}"
-				  ]),
+					]),
 			"// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration",
 			'// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.',
 			'if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");',
@@ -61,7 +77,7 @@ class AutoPublicPathRuntimeModule extends RuntimeModule {
 				? `${RuntimeGlobals.publicPath} = scriptUrl;`
 				: `${RuntimeGlobals.publicPath} = scriptUrl + ${JSON.stringify(
 						undoPath
-				  )};`
+					)};`
 		]);
 	}
 }

package/lib/runtime/BaseUriRuntimeModule.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Ivan Kopeykin @vankop
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const RuntimeModule = require("../RuntimeModule");
+
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
+/** @typedef {import("../Chunk")} Chunk */
+
+class BaseUriRuntimeModule extends RuntimeModule {
+	constructor() {
+		super("base uri", RuntimeModule.STAGE_ATTACH);
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const options =
+			/** @type {EntryDescriptionNormalized} */
+			(chunk.getEntryOptions());
+		return `${RuntimeGlobals.baseURI} = ${
+			options.baseUri === undefined
+				? "undefined"
+				: JSON.stringify(options.baseUri)
+		};`;
+	}
+}
+
+module.exports = BaseUriRuntimeModule;

package/lib/runtime/ChunkNameRuntimeModule.js

@@ -17,7 +17,7 @@ class ChunkNameRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
 		return `${RuntimeGlobals.chunkName} = ${JSON.stringify(this.chunkName)};`;

package/lib/runtime/CompatGetDefaultExportRuntimeModule.js

@@ -8,16 +8,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class CompatGetDefaultExportRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("compat get default export");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.compatGetDefaultExport;
 		return Template.asString([
 			"// getDefaultExport function for compatibility with non-harmony modules",

package/lib/runtime/CompatRuntimeModule.js

@@ -7,6 +7,9 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../ChunkGraph")} ChunkGraph */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../MainTemplate")} MainTemplate */
 
 class CompatRuntimeModule extends RuntimeModule {
@@ -16,10 +19,12 @@ class CompatRuntimeModule extends RuntimeModule {
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { chunkGraph, chunk, compilation } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
 		const {
 			runtimeTemplate,
 			mainTemplate,

package/lib/runtime/CreateFakeNamespaceObjectRuntimeModule.js

@@ -8,16 +8,19 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class CreateFakeNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("create fake namespace object");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.createFakeNamespaceObject;
 		return Template.asString([
 			`var getProto = Object.getPrototypeOf ? ${runtimeTemplate.returningFunction(
@@ -34,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/CreateScriptRuntimeModule.js

@@ -0,0 +1,38 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class CreateScriptRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("trusted types script");
+	}
+
+	/**
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate, outputOptions } = compilation;
+		const { trustedTypes } = outputOptions;
+		const fn = RuntimeGlobals.createScript;
+
+		return Template.asString(
+			`${fn} = ${runtimeTemplate.returningFunction(
+				trustedTypes
+					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScript(script)`
+					: "script",
+				"script"
+			)};`
+		);
+	}
+}
+
+module.exports = CreateScriptRuntimeModule;

package/lib/runtime/CreateScriptUrlRuntimeModule.js

@@ -8,53 +8,30 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class CreateScriptUrlRuntimeModule extends HelperRuntimeModule {
 	constructor() {
-		super("trusted types");
+		super("trusted types script url");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { compilation } = this;
+		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate, outputOptions } = compilation;
 		const { trustedTypes } = outputOptions;
 		const fn = RuntimeGlobals.createScriptUrl;
 
-		if (!trustedTypes) {
-			// Skip Trusted Types logic.
-			return Template.asString([
-				`${fn} = ${runtimeTemplate.returningFunction("url", "url")};`
-			]);
-		}
-
-		return Template.asString([
-			"var policy;",
-			`${fn} = ${runtimeTemplate.basicFunction("url", [
-				"// Create Trusted Type policy if Trusted Types are available and the policy doesn't exist yet.",
-				"if (policy === undefined) {",
-				Template.indent([
-					"policy = {",
-					Template.indent([
-						`createScriptURL: ${runtimeTemplate.returningFunction(
-							"url",
-							"url"
-						)}`
-					]),
-					"};",
-					'if (typeof trustedTypes !== "undefined" && trustedTypes.createPolicy) {',
-					Template.indent([
-						`policy = trustedTypes.createPolicy(${JSON.stringify(
-							trustedTypes.policyName
-						)}, policy);`
-					]),
-					"}"
-				]),
-				"}",
-				"return policy.createScriptURL(url);"
-			])};`
-		]);
+		return Template.asString(
+			`${fn} = ${runtimeTemplate.returningFunction(
+				trustedTypes
+					? `${RuntimeGlobals.getTrustedTypesPolicy}().createScriptURL(url)`
+					: "url",
+				"url"
+			)};`
+		);
 	}
 }
 

package/lib/runtime/DefinePropertyGettersRuntimeModule.js

@@ -8,21 +8,24 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
 
+/** @typedef {import("../Compilation")} Compilation */
+
 class DefinePropertyGettersRuntimeModule extends HelperRuntimeModule {
 	constructor() {
 		super("define property getters");
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		const fn = RuntimeGlobals.definePropertyGetters;
 		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

@@ -8,46 +8,60 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
+/** @typedef {import("../Compilation")} Compilation */
+/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+
 class EnsureChunkRuntimeModule extends RuntimeModule {
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 */
 	constructor(runtimeRequirements) {
 		super("ensure chunk");
 		this.runtimeRequirements = runtimeRequirements;
 	}
 
 	/**
-	 * @returns {string} runtime code
+	 * @returns {string | null} runtime code
 	 */
 	generate() {
-		const { runtimeTemplate } = this.compilation;
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
 		// Check if there are non initial chunks which need to be imported using require-ensure
 		if (this.runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)) {
+			const withFetchPriority = this.runtimeRequirements.has(
+				RuntimeGlobals.hasFetchPriority
+			);
 			const handlers = RuntimeGlobals.ensureChunkHandlers;
 			return Template.asString([
 				`${handlers} = {};`,
 				"// This file contains only the entry chunk.",
 				"// The chunk loading function for additional chunks",
 				`${RuntimeGlobals.ensureChunk} = ${runtimeTemplate.basicFunction(
-					"chunkId",
+					`chunkId${withFetchPriority ? ", fetchPriority" : ""}`,
 					[
 						`return Promise.all(Object.keys(${handlers}).reduce(${runtimeTemplate.basicFunction(
 							"promises, key",
-							[`${handlers}[key](chunkId, promises);`, "return promises;"]
+							[
+								`${handlers}[key](chunkId, promises${
+									withFetchPriority ? ", fetchPriority" : ""
+								});`,
+								"return promises;"
+							]
 						)}, []));`
 					]
 				)};`
 			]);
-		} 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()"
+			)};`
+		]);
 	}
 }