webpack 5.76.1 → 5.88.2

package/lib/javascript/JavascriptParserHelpers.js

@@ -9,20 +9,26 @@ const UnsupportedFeatureWarning = require("../UnsupportedFeatureWarning");
 const ConstDependency = require("../dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
-/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Expression} Expression */
 /** @typedef {import("estree").Node} Node */
+/** @typedef {import("estree").SourceLocation} SourceLocation */
 /** @typedef {import("./JavascriptParser")} JavascriptParser */
+/** @typedef {import("./JavascriptParser").Range} Range */
 
 /**
  * @param {JavascriptParser} parser the parser
  * @param {string} value the const value
  * @param {string[]=} runtimeRequirements runtime requirements
- * @returns {function(ExpressionNode): true} plugin function
+ * @returns {function(Expression): true} plugin function
  */
 exports.toConstantDependency = (parser, value, runtimeRequirements) => {
 	return function constDependency(expr) {
-		const dep = new ConstDependency(value, expr.range, runtimeRequirements);
-		dep.loc = expr.loc;
+		const dep = new ConstDependency(
+			value,
+			/** @type {Range} */ (expr.range),
+			runtimeRequirements
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
 		parser.state.module.addPresentationalDependency(dep);
 		return true;
 	};
@@ -30,33 +36,37 @@ exports.toConstantDependency = (parser, value, runtimeRequirements) => {
 
 /**
  * @param {string} value the string value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToString = value => {
 	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setString(value).setRange(expr.range);
+		return new BasicEvaluatedExpression()
+			.setString(value)
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
 /**
  * @param {number} value the number value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToNumber = value => {
 	return function stringExpression(expr) {
-		return new BasicEvaluatedExpression().setNumber(value).setRange(expr.range);
+		return new BasicEvaluatedExpression()
+			.setNumber(value)
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
 /**
  * @param {boolean} value the boolean value
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} plugin function
+ * @returns {function(Expression): BasicEvaluatedExpression} plugin function
  */
 exports.evaluateToBoolean = value => {
 	return function booleanExpression(expr) {
 		return new BasicEvaluatedExpression()
 			.setBoolean(value)
-			.setRange(expr.range);
+			.setRange(/** @type {Range} */ (expr.range));
 	};
 };
 
@@ -65,14 +75,14 @@ exports.evaluateToBoolean = value => {
  * @param {string} rootInfo rootInfo
  * @param {function(): string[]} getMembers getMembers
  * @param {boolean|null=} truthy is truthy, null if nullish
- * @returns {function(ExpressionNode): BasicEvaluatedExpression} callback
+ * @returns {function(Expression): BasicEvaluatedExpression} callback
  */
 exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 	return function identifierExpression(expr) {
 		let evaluatedExpression = new BasicEvaluatedExpression()
 			.setIdentifier(identifier, rootInfo, getMembers)
 			.setSideEffects(false)
-			.setRange(expr.range);
+			.setRange(/** @type {Range} */ (expr.range));
 		switch (truthy) {
 			case true:
 				evaluatedExpression.setTruthy();
@@ -89,14 +99,26 @@ exports.evaluateToIdentifier = (identifier, rootInfo, getMembers, truthy) => {
 	};
 };
 
+/**
+ * @param {JavascriptParser} parser the parser
+ * @param {string} message the message
+ * @returns {function(Expression): boolean | undefined} callback to handle unsupported expression
+ */
 exports.expressionIsUnsupported = (parser, message) => {
 	return function unsupportedExpression(expr) {
-		const dep = new ConstDependency("(void 0)", expr.range, null);
-		dep.loc = expr.loc;
+		const dep = new ConstDependency(
+			"(void 0)",
+			/** @type {Range} */ (expr.range),
+			null
+		);
+		dep.loc = /** @type {SourceLocation} */ (expr.loc);
 		parser.state.module.addPresentationalDependency(dep);
 		if (!parser.state.module) return;
 		parser.state.module.addWarning(
-			new UnsupportedFeatureWarning(message, expr.loc)
+			new UnsupportedFeatureWarning(
+				message,
+				/** @type {SourceLocation} */ (expr.loc)
+			)
 		);
 		return true;
 	};

package/lib/javascript/StartupHelpers.js

@@ -19,7 +19,7 @@ const { getAllChunks } = require("./ChunkHelpers");
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
 /** @typedef {(string|number)[]} EntryItem */
 
-const EXPORT_PREFIX = "var __webpack_exports__ = ";
+const EXPORT_PREFIX = `var ${RuntimeGlobals.exports} = `;
 
 /**
  * @param {ChunkGraph} chunkGraph chunkGraph
@@ -39,7 +39,7 @@ exports.generateEntryStartup = (
 	/** @type {string[]} */
 	const runtime = [
 		`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-			`__webpack_require__(${RuntimeGlobals.entryModuleId} = moduleId)`,
+			`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
 			"moduleId"
 		)}`
 	];

package/lib/json/JsonData.js

@@ -7,9 +7,19 @@
 
 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 */
+
 class JsonData {
+	/**
+	 * @param {Buffer | RawJsonData} data JSON data
+	 */
 	constructor(data) {
+		/** @type {Buffer | undefined} */
 		this._buffer = undefined;
+		/** @type {RawJsonData | undefined} */
 		this._data = undefined;
 		if (Buffer.isBuffer(data)) {
 			this._buffer = data;
@@ -18,6 +28,9 @@ class JsonData {
 		}
 	}
 
+	/**
+	 * @returns {RawJsonData|undefined} Raw JSON data
+	 */
 	get() {
 		if (this._data === undefined && this._buffer !== undefined) {
 			this._data = JSON.parse(this._buffer.toString());
@@ -25,22 +38,34 @@ class JsonData {
 		return this._data;
 	}
 
+	/**
+	 * @param {Hash} hash hash to be updated
+	 * @returns {void} the updated hash
+	 */
 	updateHash(hash) {
 		if (this._buffer === undefined && this._data !== undefined) {
 			this._buffer = Buffer.from(JSON.stringify(this._data));
 		}
 
-		if (this._buffer) return hash.update(this._buffer);
+		if (this._buffer) hash.update(this._buffer);
 	}
 }
 
 register(JsonData, "webpack/lib/json/JsonData", null, {
+	/**
+	 * @param {JsonData} obj JSONData object
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize(obj, { write }) {
 		if (obj._buffer === undefined && obj._data !== undefined) {
 			obj._buffer = Buffer.from(JSON.stringify(obj._data));
 		}
 		write(obj._buffer);
 	},
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {JsonData} deserialized JSON data
+	 */
 	deserialize({ read }) {
 		return new JsonData(read());
 	}

package/lib/json/JsonGenerator.js

@@ -17,7 +17,13 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 /** @typedef {import("../Module").ConcatenationBailoutReasonContext} ConcatenationBailoutReasonContext */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./JsonData")} JsonData */
+/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
 
+/**
+ * @param {RawJsonData} data Raw JSON data
+ * @returns {undefined|string} stringified data
+ */
 const stringifySafe = data => {
 	const stringified = JSON.stringify(data);
 	if (!stringified) {
@@ -30,21 +36,23 @@ const stringifySafe = data => {
 };
 
 /**
- * @param {Object} data data (always an object or array)
+ * @param {RawJsonData} data Raw JSON data (always an object or array)
  * @param {ExportsInfo} exportsInfo exports info
  * @param {RuntimeSpec} runtime the runtime
- * @returns {Object} reduced data
+ * @returns {RawJsonData} reduced data
  */
 const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 	if (exportsInfo.otherExportsInfo.getUsed(runtime) !== UsageState.Unused)
 		return data;
 	const isArray = Array.isArray(data);
+	/** @type {RawJsonData} */
 	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} */
 		let value;
 		if (used === UsageState.OnlyPropertiesUsed && exportInfo.exportsInfo) {
 			value = createObjectForExportsInfo(
@@ -55,8 +63,9 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 		} else {
 			value = data[key];
 		}
-		const name = exportInfo.getUsedName(key, runtime);
-		reducedData[name] = value;
+
+		const name = /** @type {string} */ (exportInfo.getUsedName(key, runtime));
+		/** @type {Record<string, RawJsonData>} */ (reducedData)[name] = value;
 	}
 	if (isArray) {
 		let arrayLengthWhenUsed =
@@ -86,6 +95,7 @@ const createObjectForExportsInfo = (data, exportsInfo, runtime) => {
 					: { length: arrayLengthWhenUsed },
 				reducedData
 			);
+		/** @type {number} */
 		const generatedLength =
 			arrayLengthWhenUsed !== undefined
 				? Math.max(arrayLengthWhenUsed, reducedData.length)
@@ -116,12 +126,13 @@ class JsonGenerator extends Generator {
 	 * @returns {number} estimate size of the module
 	 */
 	getSize(module, type) {
-		let data =
+		/** @type {RawJsonData | undefined} */
+		const data =
 			module.buildInfo &&
 			module.buildInfo.jsonData &&
 			module.buildInfo.jsonData.get();
 		if (!data) return 0;
-		return stringifySafe(data).length + 10;
+		return /** @type {string} */ (stringifySafe(data)).length + 10;
 	}
 
 	/**
@@ -148,6 +159,7 @@ class JsonGenerator extends Generator {
 			concatenationScope
 		}
 	) {
+		/** @type {RawJsonData | undefined} */
 		const data =
 			module.buildInfo &&
 			module.buildInfo.jsonData &&
@@ -160,6 +172,7 @@ class JsonGenerator extends Generator {
 			);
 		}
 		const exportsInfo = moduleGraph.getExportsInfo(module);
+		/** @type {RawJsonData} */
 		let finalJson =
 			typeof data === "object" &&
 			data &&
@@ -167,11 +180,12 @@ class JsonGenerator extends Generator {
 				? createObjectForExportsInfo(data, exportsInfo, runtime)
 				: data;
 		// Use JSON because JSON.parse() is much faster than JavaScript evaluation
-		const jsonStr = stringifySafe(finalJson);
+		const jsonStr = /** @type {string} */ (stringifySafe(finalJson));
 		const jsonExpr =
 			jsonStr.length > 20 && typeof finalJson === "object"
 				? `JSON.parse('${jsonStr.replace(/[\\']/g, "\\$&")}')`
 				: jsonStr;
+		/** @type {string} */
 		let content;
 		if (concatenationScope) {
 			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${

package/lib/json/JsonModulesPlugin.js

@@ -5,11 +5,13 @@
 
 "use strict";
 
+const { JSON_MODULE_TYPE } = require("../ModuleTypeConstants");
 const createSchemaValidation = require("../util/create-schema-validation");
 const JsonGenerator = require("./JsonGenerator");
 const JsonParser = require("./JsonParser");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {Record<string, any>} RawJsonData */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/JsonModulesPluginParser.check.js"),
@@ -20,26 +22,33 @@ const validate = createSchemaValidation(
 	}
 );
 
+const PLUGIN_NAME = "JsonModulesPlugin";
+
+/**
+ * The JsonModulesPlugin is the entrypoint plugin for the json modules feature.
+ * It adds the json module type to the compiler and registers the json parser and generator.
+ */
 class JsonModulesPlugin {
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
 	 * @returns {void}
+	 *
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"JsonModulesPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.createParser
-					.for("json")
-					.tap("JsonModulesPlugin", parserOptions => {
+					.for(JSON_MODULE_TYPE)
+					.tap(PLUGIN_NAME, parserOptions => {
 						validate(parserOptions);
 
 						return new JsonParser(parserOptions);
 					});
 				normalModuleFactory.hooks.createGenerator
-					.for("json")
-					.tap("JsonModulesPlugin", () => {
+					.for(JSON_MODULE_TYPE)
+					.tap(PLUGIN_NAME, () => {
 						return new JsonGenerator();
 					});
 			}

package/lib/json/JsonParser.js

@@ -5,14 +5,19 @@
 
 "use strict";
 
-const parseJson = require("json-parse-even-better-errors");
 const Parser = require("../Parser");
 const JsonExportsDependency = require("../dependencies/JsonExportsDependency");
+const memoize = require("../util/memoize");
 const JsonData = require("./JsonData");
 
 /** @typedef {import("../../declarations/plugins/JsonModulesPluginParser").JsonModulesPluginParserOptions} JsonModulesPluginParserOptions */
+/** @typedef {import("../Module").BuildInfo} BuildInfo */
+/** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {import("./JsonModulesPlugin").RawJsonData} RawJsonData */
+
+const getParseJson = memoize(() => require("json-parse-even-better-errors"));
 
 class JsonParser extends Parser {
 	/**
@@ -33,19 +38,28 @@ class JsonParser extends Parser {
 			source = source.toString("utf-8");
 		}
 
-		/** @type {JsonModulesPluginParserOptions["parse"]} */
+		/** @type {NonNullable<JsonModulesPluginParserOptions["parse"]>} */
 		const parseFn =
-			typeof this.options.parse === "function" ? this.options.parse : parseJson;
-
-		const data =
-			typeof source === "object"
-				? source
-				: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
-		const jsonData = new JsonData(data);
-		state.module.buildInfo.jsonData = jsonData;
-		state.module.buildInfo.strict = true;
-		state.module.buildMeta.exportsType = "default";
-		state.module.buildMeta.defaultObject =
+			typeof this.options.parse === "function"
+				? this.options.parse
+				: getParseJson();
+		/** @type {Buffer | RawJsonData | undefined} */
+		let data;
+		try {
+			data =
+				typeof source === "object"
+					? source
+					: parseFn(source[0] === "\ufeff" ? source.slice(1) : source);
+		} catch (e) {
+			throw new Error(`Cannot parse JSON: ${/** @type {Error} */ (e).message}`);
+		}
+		const jsonData = new JsonData(/** @type {Buffer | RawJsonData} */ (data));
+		const buildInfo = /** @type {BuildInfo} */ (state.module.buildInfo);
+		buildInfo.jsonData = jsonData;
+		buildInfo.strict = true;
+		const buildMeta = /** @type {BuildMeta} */ (state.module.buildMeta);
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject =
 			typeof data === "object" ? "redirect-warn" : false;
 		state.module.addDependency(new JsonExportsDependency(jsonData));
 		return state;

package/lib/library/AbstractLibraryPlugin.js

@@ -87,6 +87,10 @@ class AbstractLibraryPlugin {
 				}
 			);
 
+			/**
+			 * @param {Chunk} chunk chunk
+			 * @returns {TODO} options for the chunk
+			 */
 			const getOptionsForChunk = chunk => {
 				if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)
 					return false;

package/lib/library/AmdLibraryPlugin.js

@@ -29,6 +29,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /**
  * @typedef {Object} AmdLibraryPluginParsed
  * @property {string} name
+ * @property {string} amdContainer
  */
 
 /**
@@ -52,7 +53,7 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 	 * @returns {T | false} preprocess as needed by overriding
 	 */
 	parseOptions(library) {
-		const { name } = library;
+		const { name, amdContainer } = library;
 		if (this.requireAsWrapper) {
 			if (name) {
 				throw new Error(
@@ -67,7 +68,8 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 		return {
-			name: /** @type {string=} */ (name)
+			name: /** @type {string} */ (name),
+			amdContainer: /** @type {string} */ (amdContainer)
 		};
 	}
 
@@ -111,9 +113,14 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			(iife || !chunk.hasRuntime() ? " return " : "\n");
 		const fnEnd = iife ? ";\n}" : "\n}";
 
+		let amdContainerPrefix = "";
+		if (options.amdContainer) {
+			amdContainerPrefix = `${options.amdContainer}.`;
+		}
+
 		if (this.requireAsWrapper) {
 			return new ConcatSource(
-				`require(${externalsDepsArray}, ${fnStart}`,
+				`${amdContainerPrefix}require(${externalsDepsArray}, ${fnStart}`,
 				source,
 				`${fnEnd});`
 			);
@@ -123,18 +130,24 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 			});
 
 			return new ConcatSource(
-				`define(${JSON.stringify(name)}, ${externalsDepsArray}, ${fnStart}`,
+				`${amdContainerPrefix}define(${JSON.stringify(
+					name
+				)}, ${externalsDepsArray}, ${fnStart}`,
 				source,
 				`${fnEnd});`
 			);
 		} else if (externalsArguments) {
 			return new ConcatSource(
-				`define(${externalsDepsArray}, ${fnStart}`,
+				`${amdContainerPrefix}define(${externalsDepsArray}, ${fnStart}`,
 				source,
 				`${fnEnd});`
 			);
 		} else {
-			return new ConcatSource(`define(${fnStart}`, source, `${fnEnd});`);
+			return new ConcatSource(
+				`${amdContainerPrefix}define(${fnStart}`,
+				source,
+				`${fnEnd});`
+			);
 		}
 	}
 
@@ -155,6 +168,9 @@ class AmdLibraryPlugin extends AbstractLibraryPlugin {
 				chunk
 			});
 			hash.update(name);
+		} else if (options.amdContainer) {
+			hash.update("amdContainer");
+			hash.update(options.amdContainer);
 		}
 	}
 }

package/lib/library/AssignLibraryPlugin.js

@@ -7,6 +7,7 @@
 
 const { ConcatSource } = require("webpack-sources");
 const { UsageState } = require("../ExportsInfo");
+const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const propertyAccess = require("../util/propertyAccess");
 const { getEntryRuntime } = require("../util/runtime");
@@ -16,6 +17,7 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 /** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
 /** @typedef {import("../../declarations/WebpackOptions").LibraryType} LibraryType */
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -58,6 +60,7 @@ const accessWithInit = (accessor, existingLength, initLast = false) => {
 	let i = 1;
 
 	// all properties printed so far (excluding base)
+	/** @type {string[] | undefined} */
 	let propsSoFar;
 
 	// if there is existingLength, print all properties until this position as property access
@@ -141,7 +144,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 			}
 		}
 		return {
-			name: /** @type {string|string[]=} */ (name),
+			name: /** @type {string | string[]} */ (name),
 			export: library.export
 		};
 	}
@@ -172,12 +175,22 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 		moduleGraph.addExtraReason(module, "used as library export");
 	}
 
+	/**
+	 * @param {Compilation} compilation the compilation
+	 * @returns {string[]} the prefix
+	 */
 	_getPrefix(compilation) {
 		return this.prefix === "global"
 			? [compilation.runtimeTemplate.globalObject]
 			: this.prefix;
 	}
 
+	/**
+	 * @param {AssignLibraryPluginParsed} options the library options
+	 * @param {Chunk} chunk the chunk
+	 * @param {Compilation} compilation the compilation
+	 * @returns {Array<string>} the resolved full name
+	 */
 	_getResolvedFullName(options, chunk, compilation) {
 		const prefix = this._getPrefix(compilation);
 		const fullName = options.name ? prefix.concat(options.name) : prefix;
@@ -296,7 +309,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 				if (!exportInfo.provided) continue;
 				const nameAccess = propertyAccess([exportInfo.name]);
 				result.add(
-					`${exportTarget}${nameAccess} = __webpack_exports__${exportAccess}${nameAccess};\n`
+					`${exportTarget}${nameAccess} = ${RuntimeGlobals.exports}${exportAccess}${nameAccess};\n`
 				);
 			}
 			result.add(
@@ -310,10 +323,11 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 					true
 				)};\n`
 			);
-			let exports = "__webpack_exports__";
+			/** @type {String} */
+			let exports = RuntimeGlobals.exports;
 			if (exportAccess) {
 				result.add(
-					`var __webpack_exports_export__ = __webpack_exports__${exportAccess};\n`
+					`var __webpack_exports_export__ = ${RuntimeGlobals.exports}${exportAccess};\n`
 				);
 				exports = "__webpack_exports_export__";
 			}
@@ -329,7 +343,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 					fullNameResolved,
 					this._getPrefix(compilation).length,
 					false
-				)} = __webpack_exports__${exportAccess};\n`
+				)} = ${RuntimeGlobals.exports}${exportAccess};\n`
 			);
 		}
 		return result;

package/lib/library/EnableLibraryPlugin.js

@@ -12,6 +12,10 @@
 /** @type {WeakMap<Compiler, Set<LibraryType>>} */
 const enabledTypes = new WeakMap();
 
+/**
+ * @param {Compiler} compiler the compiler instance
+ * @returns {Set<LibraryType>} enabled types
+ */
 const getEnabledTypes = compiler => {
 	let set = enabledTypes.get(compiler);
 	if (set === undefined) {

package/lib/library/ExportPropertyLibraryPlugin.js

@@ -7,6 +7,7 @@
 
 const { ConcatSource } = require("webpack-sources");
 const { UsageState } = require("../ExportsInfo");
+const RuntimeGlobals = require("../RuntimeGlobals");
 const propertyAccess = require("../util/propertyAccess");
 const { getEntryRuntime } = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
@@ -103,7 +104,9 @@ class ExportPropertyLibraryPlugin extends AbstractLibraryPlugin {
 	 */
 	renderStartup(source, module, renderContext, { options }) {
 		if (!options.export) return source;
-		const postfix = `__webpack_exports__ = __webpack_exports__${propertyAccess(
+		const postfix = `${RuntimeGlobals.exports} = ${
+			RuntimeGlobals.exports
+		}${propertyAccess(
 			Array.isArray(options.export) ? options.export : [options.export]
 		)};\n`;
 		return new ConcatSource(source, postfix);

package/lib/library/ModuleLibraryPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
+const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
 const propertyAccess = require("../util/propertyAccess");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
@@ -80,16 +81,19 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const exports = [];
 		const isAsync = moduleGraph.isAsync(module);
 		if (isAsync) {
-			result.add(`__webpack_exports__ = await __webpack_exports__;\n`);
+			result.add(
+				`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
+			);
 		}
 		for (const exportInfo of exportsInfo.orderedExports) {
 			if (!exportInfo.provided) continue;
-			const varName = `__webpack_exports__${Template.toIdentifier(
+			const varName = `${RuntimeGlobals.exports}${Template.toIdentifier(
 				exportInfo.name
 			)}`;
 			result.add(
-				`var ${varName} = __webpack_exports__${propertyAccess([
-					exportInfo.getUsedName(exportInfo.name, chunk.runtime)
+				`var ${varName} = ${RuntimeGlobals.exports}${propertyAccess([
+					/** @type {string} */
+					(exportInfo.getUsedName(exportInfo.name, chunk.runtime))
 				])};\n`
 			);
 			exports.push(`${varName} as ${exportInfo.name}`);