webpack 5.40.0 → 5.42.1

package/lib/javascript/JavascriptModulesPlugin.js

@@ -17,6 +17,7 @@ const {
 const Compilation = require("../Compilation");
 const { tryRunOrWebpackError } = require("../HookWebpackError");
 const HotUpdateChunk = require("../HotUpdateChunk");
+const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const { last, someInIterable } = require("../util/IterableHelpers");
@@ -84,6 +85,17 @@ const printGeneratedCodeForStack = (module, code) => {
  * @property {string} hash hash to be used for render call
  */
 
+/**
+ * @typedef {Object} ChunkRenderContext
+ * @property {Chunk} chunk the chunk
+ * @property {DependencyTemplates} dependencyTemplates the dependency templates
+ * @property {RuntimeTemplate} runtimeTemplate the runtime template
+ * @property {ModuleGraph} moduleGraph the module graph
+ * @property {ChunkGraph} chunkGraph the chunk graph
+ * @property {CodeGenerationResults} codeGenerationResults results of code generation
+ * @property {InitFragment<ChunkRenderContext>[]} chunkInitFragments init fragments for the chunk
+ */
+
 /**
  * @typedef {Object} RenderBootstrapContext
  * @property {Chunk} chunk the chunk
@@ -97,11 +109,12 @@ const printGeneratedCodeForStack = (module, code) => {
 
 /**
  * @typedef {Object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, RenderContext]>} renderModuleContent
- * @property {SyncWaterfallHook<[Source, Module, RenderContext]>} renderModuleContainer
- * @property {SyncWaterfallHook<[Source, Module, RenderContext]>} renderModulePackage
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContent
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModuleContainer
+ * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderChunk
  * @property {SyncWaterfallHook<[Source, RenderContext]>} renderMain
+ * @property {SyncWaterfallHook<[Source, RenderContext]>} renderContent
  * @property {SyncWaterfallHook<[Source, RenderContext]>} render
  * @property {SyncWaterfallHook<[Source, Module, StartupRenderContext]>} renderStartup
  * @property {SyncWaterfallHook<[string, RenderBootstrapContext]>} renderRequire
@@ -145,6 +158,7 @@ class JavascriptModulesPlugin {
 					"renderContext"
 				]),
 				render: new SyncWaterfallHook(["source", "renderContext"]),
+				renderContent: new SyncWaterfallHook(["source", "renderContext"]),
 				renderStartup: new SyncWaterfallHook([
 					"source",
 					"module",
@@ -462,7 +476,7 @@ class JavascriptModulesPlugin {
 
 	/**
 	 * @param {Module} module the rendered module
-	 * @param {RenderContext} renderContext options object
+	 * @param {ChunkRenderContext} renderContext options object
 	 * @param {CompilationHooks} hooks hooks
 	 * @param {boolean | "strict"} factory true: renders as factory method, "strict": renders as factory method already in strict scope, false: pure module content
 	 * @returns {Source} the newly generated source from rendering
@@ -471,12 +485,16 @@ class JavascriptModulesPlugin {
 		const { chunk, chunkGraph, runtimeTemplate, codeGenerationResults } =
 			renderContext;
 		try {
-			const moduleSource = codeGenerationResults.getSource(
-				module,
-				chunk.runtime,
-				"javascript"
-			);
+			const codeGenResult = codeGenerationResults.get(module, chunk.runtime);
+			const moduleSource = codeGenResult.sources.get("javascript");
 			if (!moduleSource) return null;
+			if (codeGenResult.data !== undefined) {
+				const chunkInitFragments = codeGenResult.data.get("chunkInitFragments");
+				if (chunkInitFragments) {
+					for (const i of chunkInitFragments)
+						renderContext.chunkInitFragments.push(i);
+				}
+			}
 			const moduleSourcePostContent = tryRunOrWebpackError(
 				() =>
 					hooks.renderModuleContent.call(moduleSource, module, renderContext),
@@ -580,20 +598,44 @@ class JavascriptModulesPlugin {
 			"javascript",
 			compareModulesByIdentifier
 		);
+		/** @type {ChunkRenderContext} */
+		const chunkRenderContext = {
+			...renderContext,
+			chunkInitFragments: []
+		};
 		const moduleSources =
 			Template.renderChunkModules(
-				renderContext,
+				chunkRenderContext,
 				modules ? Array.from(modules) : [],
-				module => this.renderModule(module, renderContext, hooks, true)
+				module => this.renderModule(module, chunkRenderContext, hooks, true)
 			) || new RawSource("{}");
 		let source = tryRunOrWebpackError(
-			() => hooks.renderChunk.call(moduleSources, renderContext),
+			() => hooks.renderChunk.call(moduleSources, chunkRenderContext),
 			"JavascriptModulesPlugin.getCompilationHooks().renderChunk"
 		);
 		source = tryRunOrWebpackError(
-			() => hooks.render.call(source, renderContext),
+			() => hooks.renderContent.call(source, chunkRenderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
+		);
+		if (!source) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
+			);
+		}
+		source = InitFragment.addToSource(
+			source,
+			chunkRenderContext.chunkInitFragments,
+			chunkRenderContext
+		);
+		source = tryRunOrWebpackError(
+			() => hooks.render.call(source, chunkRenderContext),
 			"JavascriptModulesPlugin.getCompilationHooks().render"
 		);
+		if (!source) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().render plugins should return something"
+			);
+		}
 		chunk.rendered = true;
 		return new ConcatSource(source, ";");
 	}
@@ -607,6 +649,12 @@ class JavascriptModulesPlugin {
 	renderMain(renderContext, hooks, compilation) {
 		const { chunk, chunkGraph, runtimeTemplate } = renderContext;
 
+		/** @type {ChunkRenderContext} */
+		const chunkRenderContext = {
+			...renderContext,
+			chunkInitFragments: []
+		};
+
 		const runtimeRequirements = chunkGraph.getTreeRuntimeRequirements(chunk);
 		const iife = runtimeTemplate.isIIFE();
 
@@ -654,14 +702,14 @@ class JavascriptModulesPlugin {
 		}
 
 		const chunkModules = Template.renderChunkModules(
-			renderContext,
+			chunkRenderContext,
 			inlinedModules
 				? allModules.filter(m => !inlinedModules.has(m))
 				: allModules,
 			module =>
 				this.renderModule(
 					module,
-					renderContext,
+					chunkRenderContext,
 					hooks,
 					allStrict ? "strict" : true
 				),
@@ -670,7 +718,8 @@ class JavascriptModulesPlugin {
 		if (
 			chunkModules ||
 			runtimeRequirements.has(RuntimeGlobals.moduleFactories) ||
-			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly)
+			runtimeRequirements.has(RuntimeGlobals.moduleFactoriesAddOnly) ||
+			runtimeRequirements.has(RuntimeGlobals.require)
 		) {
 			source.add(prefix + "var __webpack_modules__ = (");
 			source.add(chunkModules || "{}");
@@ -731,7 +780,7 @@ class JavascriptModulesPlugin {
 			for (const m of inlinedModules) {
 				const renderedModule = this.renderModule(
 					m,
-					renderContext,
+					chunkRenderContext,
 					hooks,
 					false
 				);
@@ -852,6 +901,20 @@ class JavascriptModulesPlugin {
 				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderMain plugins should return something"
 			);
 		}
+		finalSource = tryRunOrWebpackError(
+			() => hooks.renderContent.call(finalSource, renderContext),
+			"JavascriptModulesPlugin.getCompilationHooks().renderContent"
+		);
+		if (!finalSource) {
+			throw new Error(
+				"JavascriptModulesPlugin error: JavascriptModulesPlugin.getCompilationHooks().renderContent plugins should return something"
+			);
+		}
+		finalSource = InitFragment.addToSource(
+			finalSource,
+			chunkRenderContext.chunkInitFragments,
+			chunkRenderContext
+		);
 		finalSource = tryRunOrWebpackError(
 			() => hooks.render.call(finalSource, renderContext),
 			"JavascriptModulesPlugin.getCompilationHooks().render"

package/lib/javascript/JavascriptParser.js

@@ -25,6 +25,8 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").Comment} CommentNode */
 /** @typedef {import("estree").ConditionalExpression} ConditionalExpressionNode */
 /** @typedef {import("estree").Declaration} DeclarationNode */
+/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifierNode */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinitionNode */
 /** @typedef {import("estree").Expression} ExpressionNode */
 /** @typedef {import("estree").Identifier} IdentifierNode */
 /** @typedef {import("estree").IfStatement} IfStatementNode */
@@ -128,7 +130,6 @@ const defaultParserOptions = {
 	locations: true,
 	ecmaVersion: "latest",
 	sourceType: "module",
-	allowAwaitOutsideFunction: true,
 	onComment: null
 };
 

package/lib/json/JsonGenerator.js

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

package/lib/node/NodeTargetPlugin.js

@@ -69,7 +69,7 @@ class NodeTargetPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		new ExternalsPlugin("commonjs", builtins).apply(compiler);
+		new ExternalsPlugin("node-commonjs", builtins).apply(compiler);
 	}
 }
 

package/lib/node/ReadFileCompileAsyncWasmPlugin.js

@@ -12,6 +12,10 @@ const AsyncWasmChunkLoadingRuntimeModule = require("../wasm-async/AsyncWasmChunk
 /** @typedef {import("../Compiler")} Compiler */
 
 class ReadFileCompileAsyncWasmPlugin {
+	constructor({ type = "async-node", import: useImport = false } = {}) {
+		this._type = type;
+		this._import = useImport;
+	}
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -28,32 +32,50 @@ class ReadFileCompileAsyncWasmPlugin {
 						options && options.wasmLoading !== undefined
 							? options.wasmLoading
 							: globalWasmLoading;
-					return wasmLoading === "async-node";
+					return wasmLoading === this._type;
 				};
-				const generateLoadBinaryCode = path =>
-					Template.asString([
-						"new Promise(function (resolve, reject) {",
-						Template.indent([
-							"var { readFile } = require('fs');",
-							"var { join } = require('path');",
-							"",
-							"try {",
-							Template.indent([
-								`readFile(join(__dirname, ${path}), function(err, buffer){`,
+				const generateLoadBinaryCode = this._import
+					? path =>
+							Template.asString([
+								"Promise.all([import('fs'), import('url')]).then(([{ readFile }, { URL }]) => new Promise((resolve, reject) => {",
 								Template.indent([
-									"if (err) return reject(err);",
-									"",
-									"// Fake fetch response",
-									"resolve({",
-									Template.indent(["arrayBuffer() { return buffer; }"]),
+									`readFile(new URL(${path}, import.meta.url), (err, buffer) => {`,
+									Template.indent([
+										"if (err) return reject(err);",
+										"",
+										"// Fake fetch response",
+										"resolve({",
+										Template.indent(["arrayBuffer() { return buffer; }"]),
+										"});"
+									]),
 									"});"
 								]),
-								"});"
-							]),
-							"} catch (err) { reject(err); }"
-						]),
-						"})"
-					]);
+								"}))"
+							])
+					: path =>
+							Template.asString([
+								"new Promise(function (resolve, reject) {",
+								Template.indent([
+									"try {",
+									Template.indent([
+										"var { readFile } = require('fs');",
+										"var { join } = require('path');",
+										"",
+										`readFile(join(__dirname, ${path}), function(err, buffer){`,
+										Template.indent([
+											"if (err) return reject(err);",
+											"",
+											"// Fake fetch response",
+											"resolve({",
+											Template.indent(["arrayBuffer() { return buffer; }"]),
+											"});"
+										]),
+										"});"
+									]),
+									"} catch (err) { reject(err); }"
+								]),
+								"})"
+							]);
 
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.instantiateWasm)

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -450,7 +450,7 @@ class ModuleConcatenationPlugin {
 						},
 						err => {
 							logger.timeEnd("create concatenated modules");
-							process.nextTick(() => callback(err));
+							process.nextTick(callback.bind(null, err));
 						}
 					);
 				}

package/lib/runtime/AsyncModuleRuntimeModule.js

@@ -57,19 +57,23 @@ class AsyncModuleRuntimeModule extends HelperRuntimeModule {
 								"completeQueue(queue);",
 								"queue = 0;"
 							])});`,
-							`var obj = { [webpackThen]: ${runtimeTemplate.expressionFunction(
+							`var obj = {};
+							obj[webpackThen] = ${runtimeTemplate.expressionFunction(
 								"queueFunction(queue, fn), dep.catch(reject)",
 								"fn, reject"
-							)} };`,
+							)};`,
 							"return obj;"
 						]),
 						"}"
 					]),
 					"}",
-					`return { [webpackThen]: ${runtimeTemplate.expressionFunction(
+					`var ret = {};
+					ret[webpackThen] = ${runtimeTemplate.expressionFunction(
 						"completeFunction(fn)",
 						"fn"
-					)}, [webpackExports]: dep };`
+					)};
+					ret[webpackExports] = dep;
+					return ret;`
 				])})`,
 				"deps"
 			)};`,

package/lib/serialization/BinaryMiddleware.js

@@ -165,12 +165,23 @@ class BinaryMiddleware extends SerializerMiddleware {
 		};
 		const flush = () => {
 			if (currentBuffer !== null) {
-				buffers.push(currentBuffer.slice(0, currentPosition));
+				buffers.push(
+					Buffer.from(
+						currentBuffer.buffer,
+						currentBuffer.byteOffset,
+						currentPosition
+					)
+				);
 				if (
 					!leftOverBuffer ||
 					leftOverBuffer.length < currentBuffer.length - currentPosition
-				)
-					leftOverBuffer = currentBuffer.slice(currentPosition);
+				) {
+					leftOverBuffer = Buffer.from(
+						currentBuffer.buffer,
+						currentBuffer.byteOffset + currentPosition,
+						currentBuffer.byteLength - currentPosition
+					);
+				}
 				currentBuffer = null;
 				buffersTotalLength += currentPosition;
 				currentPosition = 0;
@@ -537,12 +548,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		const isInCurrentBuffer = n => {
 			return currentIsBuffer && n + currentPosition <= currentBuffer.length;
 		};
-		/**
-		 * Reads n bytes
-		 * @param {number} n amount of bytes to read
-		 * @returns {Buffer} buffer with bytes
-		 */
-		const read = n => {
+		const ensureBuffer = () => {
 			if (!currentIsBuffer) {
 				throw new Error(
 					currentBuffer === null
@@ -550,14 +556,34 @@ class BinaryMiddleware extends SerializerMiddleware {
 						: "Unexpected lazy element in stream"
 				);
 			}
+		};
+		/**
+		 * Reads n bytes
+		 * @param {number} n amount of bytes to read
+		 * @returns {Buffer} buffer with bytes
+		 */
+		const read = n => {
+			ensureBuffer();
 			const rem = currentBuffer.length - currentPosition;
 			if (rem < n) {
-				return Buffer.concat([read(rem), read(n - rem)]);
+				const buffers = [read(rem)];
+				n -= rem;
+				ensureBuffer();
+				while (currentBuffer.length < n) {
+					const b = /** @type {Buffer} */ (currentBuffer);
+					buffers.push(b);
+					n -= b.length;
+					currentDataItem++;
+					currentBuffer =
+						currentDataItem < data.length ? data[currentDataItem] : null;
+					currentIsBuffer = Buffer.isBuffer(currentBuffer);
+					ensureBuffer();
+				}
+				buffers.push(read(n));
+				return Buffer.concat(buffers);
 			}
-			const res = /** @type {Buffer} */ (currentBuffer).slice(
-				currentPosition,
-				currentPosition + n
-			);
+			const b = /** @type {Buffer} */ (currentBuffer);
+			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
 			currentPosition += n;
 			checkOverflow();
 			return res;
@@ -568,33 +594,19 @@ class BinaryMiddleware extends SerializerMiddleware {
 		 * @returns {Buffer} buffer with bytes
 		 */
 		const readUpTo = n => {
-			if (!currentIsBuffer) {
-				throw new Error(
-					currentBuffer === null
-						? "Unexpected end of stream"
-						: "Unexpected lazy element in stream"
-				);
-			}
+			ensureBuffer();
 			const rem = currentBuffer.length - currentPosition;
 			if (rem < n) {
 				n = rem;
 			}
-			const res = /** @type {Buffer} */ (currentBuffer).slice(
-				currentPosition,
-				currentPosition + n
-			);
+			const b = /** @type {Buffer} */ (currentBuffer);
+			const res = Buffer.from(b.buffer, b.byteOffset + currentPosition, n);
 			currentPosition += n;
 			checkOverflow();
 			return res;
 		};
 		const readU8 = () => {
-			if (!currentIsBuffer) {
-				throw new Error(
-					currentBuffer === null
-						? "Unexpected end of stream"
-						: "Unexpected lazy element in stream"
-				);
-			}
+			ensureBuffer();
 			/**
 			 * There is no need to check remaining buffer size here
 			 * since {@link checkOverflow} guarantees at least one byte remaining
@@ -735,7 +747,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 				case STRING_HEADER:
 					return () => {
 						const len = readU32();
-						if (isInCurrentBuffer(len)) {
+						if (isInCurrentBuffer(len) && currentPosition + len < 0x7fffffff) {
 							result.push(
 								currentBuffer.toString(
 									undefined,
@@ -753,7 +765,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 					return () => result.push("");
 				case SHORT_STRING_HEADER | 1:
 					return () => {
-						if (currentIsBuffer) {
+						if (currentIsBuffer && currentPosition < 0x7ffffffe) {
 							result.push(
 								currentBuffer.toString(
 									"latin1",
@@ -785,7 +797,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 					} else if ((header & SHORT_STRING_HEADER) === SHORT_STRING_HEADER) {
 						const len = header & SHORT_STRING_LENGTH_MASK;
 						return () => {
-							if (isInCurrentBuffer(len)) {
+							if (
+								isInCurrentBuffer(len) &&
+								currentPosition + len < 0x7fffffff
+							) {
 								result.push(
 									currentBuffer.toString(
 										"latin1",