webpack 5.97.1 → 5.99.0

package/lib/javascript/JavascriptParserHelpers.js

@@ -19,13 +19,14 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
  * @param {JavascriptParser} parser the parser
  * @param {string} value the const value
  * @param {(string[] | null)=} runtimeRequirements runtime requirements
- * @returns {function(Expression): true} plugin function
+ * @returns {(expression: Expression) => true} plugin function
  */
 module.exports.toConstantDependency = (parser, value, runtimeRequirements) =>
 	function constDependency(expr) {
 		const dep = new ConstDependency(
 			value,
-			/** @type {Range} */ (expr.range),
+			/** @type {Range} */
+			(expr.range),
 			runtimeRequirements
 		);
 		dep.loc = /** @type {SourceLocation} */ (expr.loc);
@@ -35,7 +36,7 @@ module.exports.toConstantDependency = (parser, value, runtimeRequirements) =>
 
 /**
  * @param {string} value the string value
- * @returns {function(Expression): BasicEvaluatedExpression} plugin function
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
  */
 module.exports.evaluateToString = value =>
 	function stringExpression(expr) {
@@ -46,7 +47,7 @@ module.exports.evaluateToString = value =>
 
 /**
  * @param {number} value the number value
- * @returns {function(Expression): BasicEvaluatedExpression} plugin function
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
  */
 module.exports.evaluateToNumber = value =>
 	function stringExpression(expr) {
@@ -57,7 +58,7 @@ module.exports.evaluateToNumber = value =>
 
 /**
  * @param {boolean} value the boolean value
- * @returns {function(Expression): BasicEvaluatedExpression} plugin function
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} plugin function
  */
 module.exports.evaluateToBoolean = value =>
 	function booleanExpression(expr) {
@@ -69,9 +70,9 @@ module.exports.evaluateToBoolean = value =>
 /**
  * @param {string} identifier identifier
  * @param {string} rootInfo rootInfo
- * @param {function(): string[]} getMembers getMembers
- * @param {boolean|null=} truthy is truthy, null if nullish
- * @returns {function(Expression): BasicEvaluatedExpression} callback
+ * @param {() => string[]} getMembers getMembers
+ * @param {boolean | null=} truthy is truthy, null if nullish
+ * @returns {(expression: Expression) => BasicEvaluatedExpression} callback
  */
 module.exports.evaluateToIdentifier = (
 	identifier,
@@ -102,7 +103,7 @@ module.exports.evaluateToIdentifier = (
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} message the message
- * @returns {function(Expression): boolean | undefined} callback to handle unsupported expression
+ * @returns {(expression: Expression) => boolean | undefined} callback to handle unsupported expression
  */
 module.exports.expressionIsUnsupported = (parser, message) =>
 	function unsupportedExpression(expr) {

package/lib/javascript/StartupHelpers.js

@@ -88,6 +88,9 @@ module.exports.generateEntryStartup = (
 	let currentModuleIds;
 
 	for (const [module, entrypoint] of entries) {
+		if (!chunkGraph.getModuleSourceTypes(module).has("javascript")) {
+			continue;
+		}
 		const runtimeChunk =
 			/** @type {Entrypoint} */
 			(entrypoint).getRuntimeChunk();
@@ -162,7 +165,7 @@ module.exports.updateHashForEntryStartup = (
 /**
  * @param {Chunk} chunk the chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
- * @param {function(Chunk, ChunkGraph): boolean} filterFn filter function
+ * @param {(chunk: Chunk, chunkGraph: ChunkGraph) => boolean} filterFn filter function
  * @returns {Set<number | string>} initially fulfilled chunk ids
  */
 module.exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {

package/lib/json/JsonData.js

@@ -10,16 +10,16 @@ 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 */
+/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
 
 class JsonData {
 	/**
-	 * @param {Buffer | RawJsonData} data JSON data
+	 * @param {Buffer | JsonValue} data JSON data
 	 */
 	constructor(data) {
 		/** @type {Buffer | undefined} */
 		this._buffer = undefined;
-		/** @type {RawJsonData | undefined} */
+		/** @type {JsonValue | undefined} */
 		this._data = undefined;
 		if (Buffer.isBuffer(data)) {
 			this._buffer = data;
@@ -29,7 +29,7 @@ class JsonData {
 	}
 
 	/**
-	 * @returns {RawJsonData|undefined} Raw JSON data
+	 * @returns {JsonValue | undefined} Raw JSON data
 	 */
 	get() {
 		if (this._data === undefined && this._buffer !== undefined) {

package/lib/json/JsonGenerator.js

@@ -13,6 +13,7 @@ const { JS_TYPES } = require("../ModuleSourceTypesConstants");
 const RuntimeGlobals = require("../RuntimeGlobals");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").JsonGeneratorOptions} JsonGeneratorOptions */
 /** @typedef {import("../ExportsInfo")} ExportsInfo */
 /** @typedef {import("../Generator").GenerateContext} GenerateContext */
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
@@ -20,10 +21,12 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("./JsonData")} JsonData */
-/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
+/** @typedef {import("./JsonModulesPlugin").JsonArray} JsonArray */
+/** @typedef {import("./JsonModulesPlugin").JsonObject} JsonObject */
+/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
 
 /**
- * @param {RawJsonData} data Raw JSON data
+ * @param {JsonValue} data Raw JSON data
  * @returns {undefined|string} stringified data
  */
 const stringifySafe = data => {
@@ -38,30 +41,35 @@ const stringifySafe = data => {
 };
 
 /**
- * @param {RawJsonData} data Raw JSON data (always an object or array)
+ * @param {JsonObject | JsonArray} data Raw JSON data (always an object or array)
  * @param {ExportsInfo} exportsInfo exports info
  * @param {RuntimeSpec} runtime the runtime
- * @returns {RawJsonData} reduced data
+ * @returns {JsonObject | JsonArray} reduced data
  */
 const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
 		return data;
 	const isArray = Array.isArray(data);
-	/** @type {RawJsonData} */
+	/** @type {JsonObject | JsonArray} */
 	const reducedData = isArray ? [] : {};
 	for (const key of Object.keys(data)) {
 		const exportInfo = exportsInfo.getReadOnlyExportInfo(key);
 		const used = exportInfo.getUsed(runtime);
 		if (used === UsageState.Unused) continue;
 
-		/** @type {RawJsonData} */
+		// The real type is `JsonObject | JsonArray`, but typescript doesn't work `Object.keys(['string', 'other-string', 'etc'])` properly
+		const newData = /** @type {JsonObject} */ (data)[key];
 		const value =
-			used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo
-				? createObjectForExportsInfo(data[key], exportInfo.exportsInfo, runtime)
-				: data[key];
+			used === UsageState.OnlyPropertiesUsed &&
+			exportInfo.exportsInfo &&
+			typeof newData === "object" &&
+			newData
+				? createObjectForExportsInfo(newData, exportInfo.exportsInfo, runtime)
+				: newData;
 
 		const name = /** @type {string} */ (exportInfo.getUsedName(key, runtime));
-		/** @type {Record<string, RawJsonData>} */ (reducedData)[name] = value;
+		/** @type {JsonObject} */
+		(reducedData)[name] = value;
 	}
 	if (isArray) {
 		const arrayLengthWhenUsed =
@@ -71,8 +79,11 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 				: undefined;
 
 		let sizeObjectMinusArray = 0;
-		for (let i = 0; i < reducedData.length; i++) {
-			if (reducedData[i] === undefined) {
+		const reducedDataLength =
+			/** @type {JsonArray} */
+			(reducedData).length;
+		for (let i = 0; i < reducedDataLength; i++) {
+			if (/** @type {JsonArray} */ (reducedData)[i] === undefined) {
 				sizeObjectMinusArray -= 2;
 			} else {
 				sizeObjectMinusArray += `${i}`.length + 3;
@@ -82,7 +93,7 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 			sizeObjectMinusArray +=
 				`${arrayLengthWhenUsed}`.length +
 				8 -
-				(arrayLengthWhenUsed - reducedData.length) * 2;
+				(arrayLengthWhenUsed - reducedDataLength) * 2;
 		}
 		if (sizeObjectMinusArray < 0)
 			return Object.assign(
@@ -94,11 +105,12 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 		/** @type {number} */
 		const generatedLength =
 			arrayLengthWhenUsed !== undefined
-				? Math.max(arrayLengthWhenUsed, reducedData.length)
-				: reducedData.length;
+				? Math.max(arrayLengthWhenUsed, reducedDataLength)
+				: reducedDataLength;
 		for (let i = 0; i < generatedLength; i++) {
-			if (reducedData[i] === undefined) {
-				reducedData[i] = 0;
+			if (/** @type {JsonArray} */ (reducedData)[i] === undefined) {
+				/** @type {JsonArray} */
+				(reducedData)[i] = 0;
 			}
 		}
 	}
@@ -106,6 +118,14 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 };
 
 class JsonGenerator extends Generator {
+	/**
+	 * @param {JsonGeneratorOptions} options options
+	 */
+	constructor(options) {
+		super();
+		this.options = options;
+	}
+
 	/**
 	 * @param {NormalModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
@@ -120,7 +140,7 @@ class JsonGenerator extends Generator {
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
-		/** @type {RawJsonData | undefined} */
+		/** @type {JsonValue | undefined} */
 		const data =
 			module.buildInfo &&
 			module.buildInfo.jsonData &&
@@ -153,7 +173,7 @@ class JsonGenerator extends Generator {
 			concatenationScope
 		}
 	) {
-		/** @type {RawJsonData | undefined} */
+		/** @type {JsonValue | undefined} */
 		const data =
 			module.buildInfo &&
 			module.buildInfo.jsonData &&
@@ -166,7 +186,7 @@ class JsonGenerator extends Generator {
 			);
 		}
 		const exportsInfo = moduleGraph.getExportsInfo(module);
-		/** @type {RawJsonData} */
+		/** @type {JsonValue} */
 		const finalJson =
 			typeof data === "object" &&
 			data &&
@@ -176,9 +196,11 @@ class JsonGenerator extends Generator {
 		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
 		const jsonStr = /** @type {string} */ (stringifySafe(finalJson));
 		const jsonExpr =
-			jsonStr.length > 20 && typeof finalJson === "object"
+			this.options.JSONParse &&
+			jsonStr.length > 20 &&
+			typeof finalJson === "object"
 				? `/*#__PURE__*/JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
-				: jsonStr;
+				: jsonStr.replace(/"__proto__":/g, '["__proto__"]:');
 		/** @type {string} */
 		let content;
 		if (concatenationScope) {
@@ -194,6 +216,16 @@ class JsonGenerator extends Generator {
 		}
 		return new RawSource(content);
 	}
+
+	/**
+	 * @param {Error} error the error
+	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {GenerateContext} generateContext context for generate
+	 * @returns {Source | null} generated code
+	 */
+	generateError(error, module, generateContext) {
+		return new RawSource(`throw new Error(${JSON.stringify(error.message)});`);
+	}
 }
 
 module.exports = JsonGenerator;

package/lib/json/JsonModulesPlugin.js

@@ -11,7 +11,9 @@ const JsonGenerator = require("./JsonGenerator");
 const JsonParser = require("./JsonParser");
 
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {Record<string, any>} RawJsonData */
+/** @typedef {import("../util/fs").JsonArray} JsonArray */
+/** @typedef {import("../util/fs").JsonObject} JsonObject */
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/JsonModulesPluginParser.check.js"),
@@ -22,6 +24,15 @@ const validate = createSchemaValidation(
 	}
 );
 
+const validateGenerator = createSchemaValidation(
+	require("../../schemas/plugins/JsonModulesPluginGenerator.check.js"),
+	() => require("../../schemas/plugins/JsonModulesPluginGenerator.json"),
+	{
+		name: "Json Modules Plugin",
+		baseDataPath: "generator"
+	}
+);
+
 const PLUGIN_NAME = "JsonModulesPlugin";
 
 /**
@@ -42,12 +53,14 @@ class JsonModulesPlugin {
 					.for(JSON_MODULE_TYPE)
 					.tap(PLUGIN_NAME, parserOptions => {
 						validate(parserOptions);
-
 						return new JsonParser(parserOptions);
 					});
 				normalModuleFactory.hooks.createGenerator
 					.for(JSON_MODULE_TYPE)
-					.tap(PLUGIN_NAME, () => new JsonGenerator());
+					.tap(PLUGIN_NAME, generatorOptions => {
+						validateGenerator(generatorOptions);
+						return new JsonGenerator(generatorOptions);
+					});
 			}
 		);
 	}

package/lib/json/JsonParser.js

@@ -15,7 +15,7 @@ const JsonData = require("./JsonData");
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
+/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
 
 const getParseJson = memoize(() => require("json-parse-even-better-errors"));
 
@@ -43,7 +43,7 @@ class JsonParser extends Parser {
 			typeof this.options.parse === "function"
 				? this.options.parse
 				: getParseJson();
-		/** @type {Buffer | RawJsonData | undefined} */
+		/** @type {Buffer | JsonValue | undefined} */
 		let data;
 		try {
 			data =
@@ -55,7 +55,7 @@ class JsonParser extends Parser {
 				`Cannot parse JSON: ${/** @type {Error} */ (err).message}`
 			);
 		}
-		const jsonData = new JsonData(/** @type {Buffer | RawJsonData} */ (data));
+		const jsonData = new JsonData(/** @type {Buffer | JsonValue} */ (data));
 		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
 		buildInfo.jsonData = jsonData;
 		buildInfo.strict = true;
@@ -63,7 +63,13 @@ class JsonParser extends Parser {
 		buildMeta.exportsType = "default";
 		buildMeta.defaultObject =
 			typeof data === "object" ? "redirect-warn" : false;
-		state.module.addDependency(new JsonExportsDependency(jsonData));
+		state.module.addDependency(
+			new JsonExportsDependency(
+				jsonData,
+				/** @type {number} */
+				(this.options.exportsDepth)
+			)
+		);
 		return state;
 	}
 }

package/lib/library/AbstractLibraryPlugin.js

@@ -32,14 +32,18 @@ const COMMON_LIBRARY_NAME_MESSAGE =
  * @property {T} options
  */
 
+/**
+ * @typedef {object} AbstractLibraryPluginOptions
+ * @property {string} pluginName name of the plugin
+ * @property {LibraryType} type used library type
+ */
+
 /**
  * @template T
  */
 class AbstractLibraryPlugin {
 	/**
-	 * @param {object} options options
-	 * @param {string} options.pluginName name of the plugin
-	 * @param {LibraryType} options.type used library type
+	 * @param {AbstractLibraryPluginOptions} options options
 	 */
 	constructor({ pluginName, type }) {
 		this._pluginName = pluginName;

package/lib/library/AssignLibraryPlugin.js

@@ -19,7 +19,6 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").RenderContext} RenderContext */
 /** @typedef {import("../javascript/JavascriptModulesPlugin").StartupRenderContext} StartupRenderContext */
@@ -303,13 +302,42 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 				this._getPrefix(compilation).length,
 				true
 			);
+
+			/** @type {string[]} */
+			const provided = [];
 			for (const exportInfo of exportsInfo.orderedExports) {
 				if (!exportInfo.provided) continue;
 				const nameAccess = propertyAccess([exportInfo.name]);
 				result.add(
 					`${exportTarget}${nameAccess} = ${RuntimeGlobals.exports}${exportAccess}${nameAccess};\n`
 				);
+				provided.push(exportInfo.name);
 			}
+
+			const webpackExportTarget = accessWithInit(
+				fullNameResolved,
+				this._getPrefix(compilation).length,
+				true
+			);
+			/** @type {string} */
+			let exports = RuntimeGlobals.exports;
+			if (exportAccess) {
+				result.add(
+					`var __webpack_exports_export__ = ${RuntimeGlobals.exports}${exportAccess};\n`
+				);
+				exports = "__webpack_exports_export__";
+			}
+			result.add(`for(var __webpack_i__ in ${exports}) {\n`);
+			const hasProvided = provided.length > 0;
+			if (hasProvided) {
+				result.add(
+					`  if (${JSON.stringify(provided)}.indexOf(__webpack_i__) === -1) {\n`
+				);
+			}
+			result.add(
+				`  ${hasProvided ? "  " : ""}${webpackExportTarget}[__webpack_i__] = ${exports}[__webpack_i__];\n`
+			);
+			result.add(hasProvided ? "  }\n}\n" : "\n");
 			result.add(
 				`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`
 			);

package/lib/library/EnableLibraryPlugin.js

@@ -80,7 +80,8 @@ class EnableLibraryPlugin {
 				new ExportPropertyTemplatePlugin({
 					type,
 					nsObjectUsed: !["module", "modern-module"].includes(type),
-					runtimeExportsUsed: type !== "modern-module"
+					runtimeExportsUsed: !["module", "modern-module"].includes(type),
+					renderStartupUsed: !["module", "modern-module"].includes(type)
 				}).apply(compiler);
 			};
 			switch (type) {
@@ -212,6 +213,9 @@ class EnableLibraryPlugin {
 						compiler.options.output.iife = true;
 
 						class WarnFalseIifeUmdPlugin {
+							/**
+							 * @param {Compiler} compiler the compiler instance
+							 */
 							apply(compiler) {
 								compiler.hooks.thisCompilation.tap(
 									"WarnFalseIifeUmdPlugin",
@@ -249,7 +253,8 @@ class EnableLibraryPlugin {
 					}).apply(compiler);
 					break;
 				}
-				case "module": {
+				case "module":
+				case "modern-module": {
 					enableExportProperty();
 					const ModuleLibraryPlugin = require("./ModuleLibraryPlugin");
 					new ModuleLibraryPlugin({
@@ -257,14 +262,6 @@ class EnableLibraryPlugin {
 					}).apply(compiler);
 					break;
 				}
-				case "modern-module": {
-					enableExportProperty();
-					const ModernModuleLibraryPlugin = require("./ModernModuleLibraryPlugin");
-					new ModernModuleLibraryPlugin({
-						type
-					}).apply(compiler);
-					break;
-				}
 				default:
 					throw new Error(`Unsupported library type ${type}.
 Plugins which provide custom library types must call EnableLibraryPlugin.setEnabled(compiler, type) to disable this error.`);

package/lib/library/ExportPropertyLibraryPlugin.js

@@ -31,6 +31,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * @property {LibraryType} type
  * @property {boolean} nsObjectUsed the namespace object is used
  * @property {boolean} runtimeExportsUsed runtime exports are used
+ * @property {boolean} renderStartupUsed render startup is used
  */
 /**
  * @typedef {ExportPropertyLibraryPluginParsed} T
@@ -40,13 +41,14 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	/**
 	 * @param {ExportPropertyLibraryPluginOptions} options options
 	 */
-	constructor({ type, nsObjectUsed, runtimeExportsUsed }) {
+	constructor({ type, nsObjectUsed, runtimeExportsUsed, renderStartupUsed }) {
 		super({
 			pluginName: "ExportPropertyLibraryPlugin",
 			type
 		});
 		this.nsObjectUsed = nsObjectUsed;
 		this.runtimeExportsUsed = runtimeExportsUsed;
+		this.renderStartupUsed = renderStartupUsed;
 	}
 
 	/**
@@ -109,6 +111,7 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	 * @returns {Source} source with library export
 	 */
 	renderStartup(source, module, renderContext, { options }) {
+		if (!this.renderStartupUsed) return source;
 		if (!options.export) return source;
 		const postfix = `${RuntimeGlobals.exports} = ${
 			RuntimeGlobals.exports