webpack 5.42.1 → 5.45.1

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -67,6 +67,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		} = compilation;
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
+		const withExternalInstallChunk = this._runtimeRequirements.has(
+			RuntimeGlobals.externalInstallChunk
+		);
 		const withLoading = this._runtimeRequirements.has(
 			RuntimeGlobals.ensureChunkHandlers
 		);
@@ -110,6 +113,38 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			),
 			"};",
 			"",
+			withLoading || withExternalInstallChunk
+				? `var installChunk = ${runtimeTemplate.basicFunction("data", [
+						runtimeTemplate.destructureObject(
+							["ids", "modules", "runtime"],
+							"data"
+						),
+						'// add "modules" to the modules object,',
+						'// then flag all "ids" as loaded and fire callback',
+						"var moduleId, chunkId, i = 0;",
+						"for(moduleId in modules) {",
+						Template.indent([
+							`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
+							Template.indent(
+								`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
+							),
+							"}"
+						]),
+						"}",
+						"if(runtime) runtime(__webpack_require__);",
+						"for(;i < ids.length; i++) {",
+						Template.indent([
+							"chunkId = ids[i];",
+							`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
+							Template.indent("installedChunks[chunkId][0]();"),
+							"}",
+							"installedChunks[ids[i]] = 0;"
+						]),
+						"}",
+						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
+				  ])}`
+				: "// no install chunk",
+			"",
 			withLoading
 				? Template.asString([
 						`${fn}.j = ${runtimeTemplate.basicFunction(
@@ -137,45 +172,13 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 														rootOutputDir
 													)} + ${
 														RuntimeGlobals.getChunkScriptFilename
-													}(chunkId)).then(${runtimeTemplate.basicFunction(
-														"data",
+													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
+														"e",
 														[
-															runtimeTemplate.destructureObject(
-																["ids", "modules", "runtime"],
-																"data"
-															),
-															'// add "modules" to the modules object,',
-															'// then flag all "ids" as loaded and fire callback',
-															"var moduleId, chunkId, i = 0;",
-															"for(moduleId in modules) {",
-															Template.indent([
-																`if(${RuntimeGlobals.hasOwnProperty}(modules, moduleId)) {`,
-																Template.indent(
-																	`${RuntimeGlobals.moduleFactories}[moduleId] = modules[moduleId];`
-																),
-																"}"
-															]),
-															"}",
-															"if(runtime) runtime(__webpack_require__);",
-															"for(;i < ids.length; i++) {",
-															Template.indent([
-																"chunkId = ids[i];",
-																`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
-																Template.indent(
-																	"installedChunks[chunkId][0]();"
-																),
-																"}",
-																"installedChunks[ids[i]] = 0;"
-															]),
-															"}",
-															withOnChunkLoad
-																? `${RuntimeGlobals.onChunksLoaded}();`
-																: ""
+															"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
+															"throw e;"
 														]
-													)}, ${runtimeTemplate.basicFunction("e", [
-														"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
-														"throw e;"
-													])});`,
+													)});`,
 													`var promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
 														`installedChunkData = installedChunks[chunkId] = [resolve]`,
 														"resolve"
@@ -193,6 +196,12 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 				  ])
 				: "// no chunk on demand loading",
 			"",
+			withExternalInstallChunk
+				? Template.asString([
+						`${RuntimeGlobals.externalInstallChunk} = installChunk;`
+				  ])
+				: "// no external install chunk",
+			"",
 			withOnChunkLoad
 				? `${
 						RuntimeGlobals.onChunksLoaded

package/lib/hmr/lazyCompilationBackend.js

@@ -20,7 +20,7 @@ module.exports = (compiler, client, callback) => {
 	const activeModules = new Map();
 	const prefix = "/lazy-compilation-using-";
 
-	const server = http.createServer((req, res) => {
+	const requestListener = (req, res) => {
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
 			setTimeout(() => {
@@ -51,7 +51,8 @@ module.exports = (compiler, client, callback) => {
 			}
 		}
 		if (moduleActivated && compiler.watching) compiler.watching.invalidate();
-	});
+	};
+	const server = http.createServer(requestListener);
 	let isClosing = false;
 	/** @type {Set<import("net").Socket>} */
 	const sockets = new Set();
@@ -78,6 +79,8 @@ module.exports = (compiler, client, callback) => {
 		callback(null, {
 			dispose(callback) {
 				isClosing = true;
+				// Removing the listener is a workaround for a memory leak in node.js
+				server.off("request", requestListener);
 				server.close(err => {
 					callback(err);
 				});

package/lib/javascript/JavascriptModulesPlugin.js

@@ -834,7 +834,9 @@ class JavascriptModulesPlugin {
 				}
 			}
 			if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
-				startupSource.add(`${RuntimeGlobals.onChunksLoaded}();\n`);
+				startupSource.add(
+					`__webpack_exports__ = ${RuntimeGlobals.onChunksLoaded}(__webpack_exports__);\n`
+				);
 			}
 			source.add(
 				hooks.renderStartup.call(startupSource, lastInlinedModule, {

package/lib/json/JsonData.js

@@ -0,0 +1,41 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { register } = require("../util/serialization");
+
+class JsonData {
+	constructor(data) {
+		this._buffer = undefined;
+		this._data = undefined;
+		if (Buffer.isBuffer(data)) {
+			this._buffer = data;
+		} else {
+			this._data = data;
+		}
+	}
+
+	get() {
+		if (this._data === undefined && this._buffer !== undefined) {
+			this._data = JSON.parse(this._buffer.toString());
+		}
+		return this._data;
+	}
+}
+
+register(JsonData, "webpack/lib/json/JsonData", null, {
+	serialize(obj, { write }) {
+		if (obj._buffer === undefined && obj._data !== undefined) {
+			obj._buffer = Buffer.from(JSON.stringify(obj._data));
+		}
+		write(obj._buffer);
+	},
+	deserialize({ read }) {
+		return new JsonData(read());
+	}
+});
+
+module.exports = JsonData;

package/lib/json/JsonGenerator.js

@@ -116,7 +116,10 @@ class JsonGenerator extends Generator {
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
-		let data = module.buildInfo && module.buildInfo.jsonData;
+		let data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
 		if (!data) return 0;
 		return stringifySafe(data).length + 10;
 	}
@@ -145,7 +148,10 @@ class JsonGenerator extends Generator {
 			concatenationScope
 		}
 	) {
-		const data = module.buildInfo && module.buildInfo.jsonData;
+		const data =
+			module.buildInfo &&
+			module.buildInfo.jsonData &&
+			module.buildInfo.jsonData.get();
 		if (data === undefined) {
 			return new RawSource(
 				runtimeTemplate.missingModuleStatement({

package/lib/json/JsonParser.js

@@ -8,6 +8,7 @@
 const parseJson = require("json-parse-better-errors");
 const Parser = require("../Parser");
 const JsonExportsDependency = require("../dependencies/JsonExportsDependency");
+const JsonData = require("./JsonData");
 
 /** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
 /** @typedef {import("../Parser").ParserState} ParserState */
@@ -41,7 +42,7 @@ class JsonParser extends Parser {
 				? source
 				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
 
-		state.module.buildInfo.jsonData = data;
+		state.module.buildInfo.jsonData = new JsonData(data);
 		state.module.buildInfo.strict = true;
 		state.module.buildMeta.exportsType = "default";
 		state.module.buildMeta.defaultObject =

package/lib/library/SystemLibraryPlugin.js

@@ -72,7 +72,7 @@ class SystemLibraryPlugin extends AbstractLibraryPlugin {
 	render(source, { chunkGraph, moduleGraph, chunk }, { options, compilation }) {
 		const modules = chunkGraph
 			.getChunkModules(chunk)
-			.filter(m => m instanceof ExternalModule);
+			.filter(m => m instanceof ExternalModule && m.externalType === "system");
 		const externals = /** @type {ExternalModule[]} */ (modules);
 
 		// The name this bundle should be registered as with System

package/lib/optimize/ConcatenatedModule.js

@@ -45,6 +45,7 @@ const {
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../DependencyTemplates")} DependencyTemplates */
 /** @typedef {import("../ExportsInfo").ExportInfo} ExportInfo */
+/** @template T @typedef {import("../InitFragment")<T>} InitFragment */
 /** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
 /** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
@@ -55,6 +56,7 @@ const {
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
@@ -104,6 +106,7 @@ if (!ReferencerClass.prototype.PropertyDefinition) {
  * @property {Object} ast
  * @property {Source} internalSource
  * @property {ReplaceSource} source
+ * @property {InitFragment<ChunkRenderContext>[]=} chunkInitFragments
  * @property {Iterable<string>} runtimeRequirements
  * @property {Scope} globalScope
  * @property {Scope} moduleScope
@@ -1508,6 +1511,8 @@ ${defineGetters}`
 			}
 		}
 
+		const chunkInitFragments = [];
+
 		// evaluate modules in order
 		for (const rawInfo of modulesWithInfo) {
 			let name;
@@ -1521,6 +1526,9 @@ ${defineGetters}`
 						)}\n`
 					);
 					result.add(info.source);
+					if (info.chunkInitFragments) {
+						for (const f of info.chunkInitFragments) chunkInitFragments.push(f);
+					}
 					if (info.runtimeRequirements) {
 						for (const r of info.runtimeRequirements) {
 							runtimeRequirements.add(r);
@@ -1583,9 +1591,14 @@ ${defineGetters}`
 			}
 		}
 
+		const data = new Map();
+		if (chunkInitFragments.length > 0)
+			data.set("chunkInitFragments", chunkInitFragments);
+
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
 			sources: new Map([["javascript", new CachedSource(result)]]),
+			data,
 			runtimeRequirements
 		};
 
@@ -1626,6 +1639,8 @@ ${defineGetters}`
 					concatenationScope
 				});
 				const source = codeGenResult.sources.get("javascript");
+				const data = codeGenResult.data;
+				const chunkInitFragments = data && data.get("chunkInitFragments");
 				const code = source.source().toString();
 				let ast;
 				try {
@@ -1662,6 +1677,7 @@ ${defineGetters}`
 				info.ast = ast;
 				info.internalSource = source;
 				info.source = resultSource;
+				info.chunkInitFragments = chunkInitFragments;
 				info.globalScope = globalScope;
 				info.moduleScope = moduleScope;
 			} catch (err) {

package/lib/optimize/RuntimeChunkPlugin.js

@@ -27,7 +27,7 @@ class RuntimeChunkPlugin {
 				(_, { name: entryName }) => {
 					if (entryName === undefined) return;
 					const data = compilation.entries.get(entryName);
-					if (!data.options.runtime && !data.options.dependOn) {
+					if (data.options.runtime === undefined && !data.options.dependOn) {
 						// Determine runtime chunk name
 						let name = this.options.name;
 						if (typeof name === "function") {

package/lib/prefetch/ChunkPrefetchStartupRuntimeModule.js

@@ -32,16 +32,17 @@ class ChunkPrefetchStartupRuntimeModule extends RuntimeModule {
 					`${RuntimeGlobals.onChunksLoaded}(0, ${JSON.stringify(
 						// This need to include itself to delay execution after this chunk has been fully loaded
 						onChunks.filter(c => c === chunk).map(c => c.id)
-					)}, ${runtimeTemplate.expressionFunction(
+					)}, ${runtimeTemplate.basicFunction(
+						"",
 						chunks.size < 3
 							? Array.from(
 									chunks,
 									c =>
-										`${RuntimeGlobals.prefetchChunk}(${JSON.stringify(c.id)})`
-							  ).join(", ")
+										`${RuntimeGlobals.prefetchChunk}(${JSON.stringify(c.id)});`
+							  )
 							: `${JSON.stringify(Array.from(chunks, c => c.id))}.map(${
 									RuntimeGlobals.prefetchChunk
-							  })`
+							  });`
 					)}, 5);`
 			)
 		);

package/lib/rules/RuleSetCompiler.js

@@ -225,7 +225,7 @@ class RuleSetCompiler {
 		if (typeof condition === "string") {
 			return {
 				matchWhenEmpty: condition.length === 0,
-				fn: str => str.startsWith(condition)
+				fn: str => typeof str === "string" && str.startsWith(condition)
 			};
 		}
 		if (typeof condition === "function") {
@@ -245,7 +245,7 @@ class RuleSetCompiler {
 		if (condition instanceof RegExp) {
 			return {
 				matchWhenEmpty: condition.test(""),
-				fn: v => condition.test(v)
+				fn: v => typeof v === "string" && condition.test(v)
 			};
 		}
 		if (Array.isArray(condition)) {

package/lib/runtime/OnChunksLoadedRuntimeModule.js

@@ -58,7 +58,11 @@ class OnChunksLoadedRuntimeModule extends RuntimeModule {
 						]),
 						"}",
 						"if(fulfilled) {",
-						Template.indent(["deferred.splice(i--, 1)", "result = fn();"]),
+						Template.indent([
+							"deferred.splice(i--, 1)",
+							"var r = fn();",
+							"if (r !== undefined) result = r;"
+						]),
 						"}"
 					]),
 					"}",

package/lib/schemes/DataUriPlugin.js

@@ -11,15 +11,14 @@ const NormalModule = require("../NormalModule");
 
 // data URL scheme: "data:text/javascript;charset=utf-8;base64,some-string"
 // http://www.ietf.org/rfc/rfc2397.txt
-const URIRegEx = /^data:(?:[^;,]+)?(?:(?:;[^;,]+)*?)(;base64)?,(.*)$/i;
-const URIMetaRegEx = /^data:([^;,]+)?(?:(?:;[^;,]+)*?)(?:;(base64))?,/i;
+const URIRegEx = /^data:([^;,]+)?((?:;[^;,]+)*?)(?:;(base64))?,(.*)$/i;
 
 const decodeDataURI = uri => {
 	const match = URIRegEx.exec(uri);
 	if (!match) return null;
 
-	const isBase64 = match[1];
-	const body = match[2];
+	const isBase64 = match[3];
+	const body = match[4];
 	return isBase64
 		? Buffer.from(body, "base64")
 		: Buffer.from(decodeURIComponent(body), "ascii");
@@ -38,10 +37,12 @@ class DataUriPlugin {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("data")
 					.tap("DataUriPlugin", resourceData => {
-						const match = URIMetaRegEx.exec(resourceData.resource);
+						const match = URIRegEx.exec(resourceData.resource);
 						if (match) {
 							resourceData.data.mimetype = match[1] || "";
-							resourceData.data.encoding = match[2] || false;
+							resourceData.data.parameters = match[2] || "";
+							resourceData.data.encoding = match[3] || false;
+							resourceData.data.encodedContent = match[4] || "";
 						}
 					});
 				NormalModule.getCompilationHooks(compilation)

package/lib/util/StackedCacheMap.js

@@ -0,0 +1,110 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/**
+ * @template K
+ * @template V
+ */
+class StackedCacheMap {
+	constructor() {
+		/** @type {Map<K, V>} */
+		this.map = new Map();
+		/** @type {ReadonlyMap<K, V>[]} */
+		this.stack = [];
+	}
+
+	/**
+	 * @param {ReadonlyMap<K, V>} map map to add
+	 * @param {boolean} immutable if 'map' is immutable and StackedCacheMap can keep referencing it
+	 */
+	addAll(map, immutable) {
+		if (immutable) {
+			this.stack.push(map);
+
+			// largest map should go first
+			for (let i = this.stack.length - 1; i > 0; i--) {
+				const beforeLast = this.stack[i - 1];
+				if (beforeLast.size >= map.size) break;
+				this.stack[i] = beforeLast;
+				this.stack[i - 1] = map;
+			}
+		} else {
+			for (const [key, value] of map) {
+				this.map.set(key, value);
+			}
+		}
+	}
+
+	/**
+	 * @param {K} item the key of the element to add
+	 * @param {V} value the value of the element to add
+	 * @returns {void}
+	 */
+	set(item, value) {
+		this.map.set(item, value);
+	}
+
+	/**
+	 * @param {K} item the item to delete
+	 * @returns {void}
+	 */
+	delete(item) {
+		throw new Error("Items can't be deleted from a StackedCacheMap");
+	}
+
+	/**
+	 * @param {K} item the item to test
+	 * @returns {boolean} true if the item exists in this set
+	 */
+	has(item) {
+		throw new Error(
+			"Checking StackedCacheMap.has before reading is inefficient, use StackedCacheMap.get and check for undefined"
+		);
+	}
+
+	/**
+	 * @param {K} item the key of the element to return
+	 * @returns {V} the value of the element
+	 */
+	get(item) {
+		for (const map of this.stack) {
+			const value = map.get(item);
+			if (value !== undefined) return value;
+		}
+		return this.map.get(item);
+	}
+
+	clear() {
+		this.stack.length = 0;
+		this.map.clear();
+	}
+
+	get size() {
+		let size = this.map.size;
+		for (const map of this.stack) {
+			size += map.size;
+		}
+		return size;
+	}
+
+	[Symbol.iterator]() {
+		const iterators = this.stack.map(map => map[Symbol.iterator]());
+		let current = this.map[Symbol.iterator]();
+		return {
+			next() {
+				let result = current.next();
+				while (result.done && iterators.length > 0) {
+					current = iterators.pop();
+					result = current.next();
+				}
+				return result;
+			}
+		};
+	}
+}
+
+module.exports = StackedCacheMap;

package/lib/util/internalSerializables.js

@@ -156,6 +156,7 @@ module.exports = {
 		require("../dependencies/WebpackIsIncludedDependency"),
 	"dependencies/WorkerDependency": () =>
 		require("../dependencies/WorkerDependency"),
+	"json/JsonData": () => require("../json/JsonData"),
 	"optimize/ConcatenatedModule": () =>
 		require("../optimize/ConcatenatedModule"),
 	DelegatedModule: () => require("../DelegatedModule"),

package/lib/util/makeSerializable.js

@@ -9,7 +9,6 @@ const { register } = require("./serialization");
 class ClassSerializer {
 	constructor(Constructor) {
 		this.Constructor = Constructor;
-		this.hash = null;
 	}
 
 	serialize(obj, context) {

package/lib/webpack.js

@@ -152,7 +152,7 @@ const webpack = /** @type {WebpackFunctionSingle & WebpackFunctionMulti} */ (
 			if (watch) {
 				util.deprecate(
 					() => {},
-					"A 'callback' argument need to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
+					"A 'callback' argument needs to be provided to the 'webpack(options, callback)' function when the 'watch' option is set. There is no way to handle the 'watch' option without a callback.",
 					"DEP_WEBPACK_WATCH_WITHOUT_CALLBACK"
 				)();
 			}