webpack 5.51.2 → 5.52.0

package/lib/ExternalModule.js

@@ -13,6 +13,7 @@ const Module = require("./Module");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const StaticExportsDependency = require("./dependencies/StaticExportsDependency");
+const createHash = require("./util/createHash");
 const extractUrlAndGlobal = require("./util/extractUrlAndGlobal");
 const makeSerializable = require("./util/makeSerializable");
 const propertyAccess = require("./util/propertyAccess");
@@ -159,18 +160,25 @@ const getSourceForImportExternal = (moduleAndSpecifiers, runtimeTemplate) => {
 };
 
 class ModuleExternalInitFragment extends InitFragment {
-	constructor(id, request) {
-		const identifier = `__WEBPACK_EXTERNAL_MODULE_${Template.toIdentifier(
-			`${id}`
-		)}__`;
+	constructor(request, ident) {
+		if (ident === undefined) {
+			ident = Template.toIdentifier(request);
+			if (ident !== request) {
+				ident += `_${createHash("md4")
+					.update(request)
+					.digest("hex")
+					.slice(0, 8)}`;
+			}
+		}
+		const identifier = `__WEBPACK_EXTERNAL_MODULE_${ident}__`;
 		super(
 			`import * as ${identifier} from ${JSON.stringify(request)};\n`,
 			InitFragment.STAGE_HARMONY_IMPORTS,
 			0,
-			`external module import ${id}`
+			`external module import ${ident}`
 		);
+		this._ident = ident;
 		this._identifier = identifier;
-		this._id = id;
 		this._request = request;
 	}
 
@@ -185,8 +193,8 @@ register(
 	"ModuleExternalInitFragment",
 	{
 		serialize(obj, { write }) {
-			write(obj._id);
 			write(obj._request);
+			write(obj._ident);
 		},
 		deserialize({ read }) {
 			return new ModuleExternalInitFragment(read(), read());
@@ -236,10 +244,7 @@ const getSourceForModuleExternal = (
 ) => {
 	if (!Array.isArray(moduleAndSpecifiers))
 		moduleAndSpecifiers = [moduleAndSpecifiers];
-	const initFragment = new ModuleExternalInitFragment(
-		id,
-		moduleAndSpecifiers[0]
-	);
+	const initFragment = new ModuleExternalInitFragment(moduleAndSpecifiers[0]);
 	const baseAccess = `${initFragment.getNamespaceIdentifier()}${propertyAccess(
 		moduleAndSpecifiers,
 		1
@@ -400,7 +405,7 @@ class ExternalModule extends Module {
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
-		return "external " + JSON.stringify(this.request);
+		return `external ${this.externalType} ${JSON.stringify(this.request)}`;
 	}
 
 	/**
@@ -531,18 +536,20 @@ class ExternalModule extends Module {
 			case "umd":
 			case "umd2":
 			case "system":
-			case "jsonp":
+			case "jsonp": {
+				const id = chunkGraph.getModuleId(this);
 				return getSourceForAmdOrUmdExternal(
-					chunkGraph.getModuleId(this),
+					id !== null ? id : this.identifier(),
 					this.isOptional(moduleGraph),
 					request,
 					runtimeTemplate
 				);
+			}
 			case "import":
 				return getSourceForImportExternal(request, runtimeTemplate);
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
-			case "module":
+			case "module": {
 				if (!this.buildInfo.module) {
 					if (!runtimeTemplate.supportsDynamicImport()) {
 						throw new Error(
@@ -559,12 +566,14 @@ class ExternalModule extends Module {
 						"The target environment doesn't support EcmaScriptModule syntax so it's not possible to use external type 'module'"
 					);
 				}
+				const id = chunkGraph.getModuleId(this);
 				return getSourceForModuleExternal(
-					chunkGraph.getModuleId(this),
+					id !== null ? id : this.identifier(),
 					request,
 					moduleGraph.getExportsInfo(this),
 					runtime
 				);
+			}
 			case "var":
 			case "promise":
 			case "const":

package/lib/InitFragment.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
+const makeSerializable = require("./util/makeSerializable");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("./Generator").GenerateContext} GenerateContext */
@@ -123,8 +124,30 @@ class InitFragment {
 			return source;
 		}
 	}
+
+	serialize(context) {
+		const { write } = context;
+
+		write(this.content);
+		write(this.stage);
+		write(this.position);
+		write(this.key);
+		write(this.endContent);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+
+		this.content = read();
+		this.stage = read();
+		this.position = read();
+		this.key = read();
+		this.endContent = read();
+	}
 }
 
+makeSerializable(InitFragment, "webpack/lib/InitFragment");
+
 InitFragment.prototype.merge = undefined;
 
 InitFragment.STAGE_CONSTANTS = 10;

package/lib/NormalModuleFactory.js

@@ -540,15 +540,18 @@ class NormalModuleFactory extends ModuleFactory {
 						for (const loader of preLoaders) allLoaders.push(loader);
 						let type = settings.type;
 						if (!type) {
-							const resource =
-								(matchResourceData && matchResourceData.resource) ||
-								resourceData.resource;
+							let resource;
 							let match;
 							if (
-								typeof resource === "string" &&
+								matchResourceData &&
+								typeof (resource = matchResourceData.resource) === "string" &&
 								(match = /\.webpack\[([^\]]+)\]$/.exec(resource))
 							) {
 								type = match[1];
+								matchResourceData.resource = matchResourceData.resource.slice(
+									0,
+									-type.length - 10
+								);
 							} else {
 								type = "javascript/auto";
 							}

package/lib/WebpackOptionsApply.js

@@ -305,9 +305,7 @@ class WebpackOptionsApply extends OptionsApply {
 			new RequireJsStuffPlugin().apply(compiler);
 		}
 		new CommonJsPlugin().apply(compiler);
-		new LoaderPlugin({
-			enableExecuteModule: options.experiments.executeModule
-		}).apply(compiler);
+		new LoaderPlugin({}).apply(compiler);
 		if (options.node !== false) {
 			const NodeStuffPlugin = require("./NodeStuffPlugin");
 			new NodeStuffPlugin(options.node).apply(compiler);

package/lib/config/defaults.js

@@ -259,7 +259,6 @@ const applyExperimentsDefaults = (experiments, { production, development }) => {
 	D(experiments, "asyncWebAssembly", false);
 	D(experiments, "outputModule", false);
 	D(experiments, "asset", false);
-	D(experiments, "executeModule", false);
 	D(experiments, "layers", false);
 	D(experiments, "lazyCompilation", false);
 	D(experiments, "buildHttp", false);

package/lib/dependencies/LoaderPlugin.js

@@ -37,11 +37,9 @@ const LoaderImportDependency = require("./LoaderImportDependency");
 class LoaderPlugin {
 	/**
 	 * @param {Object} options options
-	 * @param {boolean=} options.enableExecuteModule execute module enabled
 	 */
-	constructor(options = {}) {
-		this._enableExecuteModule = !!options.enableExecuteModule;
-	}
+	constructor(options = {}) {}
+
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -155,106 +153,104 @@ class LoaderPlugin {
 						);
 					};
 
-					if (this._enableExecuteModule) {
-						/**
-						 * @param {string} request the request string to load the module from
-						 * @param {ImportModuleOptions=} options options
-						 * @param {ImportModuleCallback=} callback callback returning the exports
-						 * @returns {void}
-						 */
-						const importModule = (request, options, callback) => {
-							const dep = new LoaderImportDependency(request);
-							dep.loc = {
-								name: request
-							};
-							const factory = compilation.dependencyFactories.get(
-								/** @type {DepConstructor} */ (dep.constructor)
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions=} options options
+					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @returns {void}
+					 */
+					const importModule = (request, options, callback) => {
+						const dep = new LoaderImportDependency(request);
+						dep.loc = {
+							name: request
+						};
+						const factory = compilation.dependencyFactories.get(
+							/** @type {DepConstructor} */ (dep.constructor)
+						);
+						if (factory === undefined) {
+							return callback(
+								new Error(
+									`No module factory available for dependency type: ${dep.constructor.name}`
+								)
 							);
-							if (factory === undefined) {
-								return callback(
-									new Error(
-										`No module factory available for dependency type: ${dep.constructor.name}`
-									)
-								);
-							}
-							compilation.buildQueue.increaseParallelism();
-							compilation.handleModuleCreation(
-								{
-									factory,
-									dependencies: [dep],
-									originModule: loaderContext._module,
-									contextInfo: {
-										issuerLayer: options.layer
-									},
-									context: loaderContext.context,
-									connectOrigin: false
+						}
+						compilation.buildQueue.increaseParallelism();
+						compilation.handleModuleCreation(
+							{
+								factory,
+								dependencies: [dep],
+								originModule: loaderContext._module,
+								contextInfo: {
+									issuerLayer: options.layer
 								},
-								err => {
-									compilation.buildQueue.decreaseParallelism();
-									if (err) {
-										return callback(err);
-									}
-									const referencedModule = moduleGraph.getModule(dep);
-									if (!referencedModule) {
-										return callback(new Error("Cannot load the module"));
-									}
-									compilation.executeModule(
-										referencedModule,
-										{
-											entryOptions: {
-												publicPath: options.publicPath
-											}
-										},
-										(err, result) => {
-											if (err) return callback(err);
-											for (const d of result.fileDependencies) {
-												loaderContext.addDependency(d);
-											}
-											for (const d of result.contextDependencies) {
-												loaderContext.addContextDependency(d);
-											}
-											for (const d of result.missingDependencies) {
-												loaderContext.addMissingDependency(d);
-											}
-											for (const d of result.buildDependencies) {
-												loaderContext.addBuildDependency(d);
-											}
-											if (result.cacheable === false)
-												loaderContext.cacheable(false);
-											for (const [name, { source, info }] of result.assets) {
-												const { buildInfo } = loaderContext._module;
-												if (!buildInfo.assets) {
-													buildInfo.assets = Object.create(null);
-													buildInfo.assetsInfo = new Map();
-												}
-												buildInfo.assets[name] = source;
-												buildInfo.assetsInfo.set(name, info);
+								context: loaderContext.context,
+								connectOrigin: false
+							},
+							err => {
+								compilation.buildQueue.decreaseParallelism();
+								if (err) {
+									return callback(err);
+								}
+								const referencedModule = moduleGraph.getModule(dep);
+								if (!referencedModule) {
+									return callback(new Error("Cannot load the module"));
+								}
+								compilation.executeModule(
+									referencedModule,
+									{
+										entryOptions: {
+											publicPath: options.publicPath
+										}
+									},
+									(err, result) => {
+										if (err) return callback(err);
+										for (const d of result.fileDependencies) {
+											loaderContext.addDependency(d);
+										}
+										for (const d of result.contextDependencies) {
+											loaderContext.addContextDependency(d);
+										}
+										for (const d of result.missingDependencies) {
+											loaderContext.addMissingDependency(d);
+										}
+										for (const d of result.buildDependencies) {
+											loaderContext.addBuildDependency(d);
+										}
+										if (result.cacheable === false)
+											loaderContext.cacheable(false);
+										for (const [name, { source, info }] of result.assets) {
+											const { buildInfo } = loaderContext._module;
+											if (!buildInfo.assets) {
+												buildInfo.assets = Object.create(null);
+												buildInfo.assetsInfo = new Map();
 											}
-											callback(null, result.exports);
+											buildInfo.assets[name] = source;
+											buildInfo.assetsInfo.set(name, info);
 										}
-									);
-								}
-							);
-						};
+										callback(null, result.exports);
+									}
+								);
+							}
+						);
+					};
 
-						/**
-						 * @param {string} request the request string to load the module from
-						 * @param {ImportModuleOptions} options options
-						 * @param {ImportModuleCallback=} callback callback returning the exports
-						 * @returns {Promise<any> | void} exports
-						 */
-						loaderContext.importModule = (request, options, callback) => {
-							if (!callback) {
-								return new Promise((resolve, reject) => {
-									importModule(request, options || {}, (err, result) => {
-										if (err) reject(err);
-										else resolve(result);
-									});
+					/**
+					 * @param {string} request the request string to load the module from
+					 * @param {ImportModuleOptions} options options
+					 * @param {ImportModuleCallback=} callback callback returning the exports
+					 * @returns {Promise<any> | void} exports
+					 */
+					loaderContext.importModule = (request, options, callback) => {
+						if (!callback) {
+							return new Promise((resolve, reject) => {
+								importModule(request, options || {}, (err, result) => {
+									if (err) reject(err);
+									else resolve(result);
 								});
-							}
-							return importModule(request, options || {}, callback);
-						};
-					}
+							});
+						}
+						return importModule(request, options || {}, callback);
+					};
 				}
 			);
 		});

package/lib/optimize/MangleExportsPlugin.js

@@ -39,13 +39,28 @@ const comparator = compareSelect(e => e.name, compareStringsNumeric);
 /**
  * @param {boolean} deterministic use deterministic names
  * @param {ExportsInfo} exportsInfo exports info
+ * @param {boolean} isNamespace is namespace object
  * @returns {void}
  */
-const mangleExportsInfo = (deterministic, exportsInfo) => {
+const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 	if (!canMangle(exportsInfo)) return;
 	const usedNames = new Set();
 	/** @type {ExportInfo[]} */
 	const mangleableExports = [];
+
+	// Avoid to renamed exports that are not provided when
+	// 1. it's not a namespace export: non-provided exports can be found in prototype chain
+	// 2. there are other provided exports and deterministic mode is chosen:
+	//    non-provided exports would break the determinism
+	let avoidMangleNonProvided = !isNamespace;
+	if (!avoidMangleNonProvided && deterministic) {
+		for (const exportInfo of exportsInfo.ownedExports) {
+			if (exportInfo.provided !== false) {
+				avoidMangleNonProvided = true;
+				break;
+			}
+		}
+	}
 	for (const exportInfo of exportsInfo.ownedExports) {
 		const name = exportInfo.name;
 		if (!exportInfo.hasUsedName()) {
@@ -59,7 +74,7 @@ const mangleExportsInfo = (deterministic, exportsInfo) => {
 					name.length === 2 &&
 					/^[a-zA-Z_$][a-zA-Z0-9_$]|^[1-9][0-9]/.test(name)) ||
 				// Don't rename exports that are not provided
-				exportInfo.provided !== true
+				(avoidMangleNonProvided && exportInfo.provided !== true)
 			) {
 				exportInfo.setUsedName(name);
 				usedNames.add(name);
@@ -73,7 +88,7 @@ const mangleExportsInfo = (deterministic, exportsInfo) => {
 				used === UsageState.OnlyPropertiesUsed ||
 				used === UsageState.Unused
 			) {
-				mangleExportsInfo(deterministic, exportInfo.exportsInfo);
+				mangleExportsInfo(deterministic, exportInfo.exportsInfo, false);
 			}
 		}
 	}
@@ -143,8 +158,10 @@ class MangleExportsPlugin {
 				"MangleExportsPlugin",
 				modules => {
 					for (const module of modules) {
+						const isNamespace =
+							module.buildMeta && module.buildMeta.exportsType === "namespace";
 						const exportsInfo = moduleGraph.getExportsInfo(module);
-						mangleExportsInfo(deterministic, exportsInfo);
+						mangleExportsInfo(deterministic, exportsInfo, isNamespace);
 					}
 				}
 			);

package/lib/util/internalSerializables.js

@@ -164,6 +164,7 @@ module.exports = {
 	DllModule: () => require("../DllModule"),
 	ExternalModule: () => require("../ExternalModule"),
 	FileSystemInfo: () => require("../FileSystemInfo"),
+	InitFragment: () => require("../InitFragment"),
 	InvalidDependenciesModuleWarning: () =>
 		require("../InvalidDependenciesModuleWarning"),
 	Module: () => require("../Module"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.51.2",
+  "version": "5.52.0",
   "author": "Tobias Koppers @sokra",
   "description": "Packs CommonJs/AMD modules for the browser. Allows to split your codebase into multiple bundles, which can be loaded on demand. Support loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "license": "MIT",
@@ -58,15 +58,15 @@
     "eslint-plugin-jest": "^24.3.6",
     "eslint-plugin-jsdoc": "^33.0.0",
     "eslint-plugin-node": "^11.0.0",
-    "eslint-plugin-prettier": "^3.1.4",
+    "eslint-plugin-prettier": "^4.0.0",
     "file-loader": "^6.0.0",
     "fork-ts-checker-webpack-plugin": "^6.0.5",
     "husky": "^6.0.0",
     "is-ci": "^3.0.0",
     "istanbul": "^0.4.5",
     "jest": "^27.0.6",
-    "jest-cli": "^27.0.6",
     "jest-circus": "^27.0.6",
+    "jest-cli": "^27.0.6",
     "jest-diff": "^27.0.2",
     "jest-junit": "^12.0.0",
     "json-loader": "^0.5.7",