webpack 5.92.1 → 5.93.0

package/lib/ContextModule.js

@@ -190,8 +190,10 @@ class ContextModule extends Module {
 	 * @returns {string} pretty RegExp
 	 */
 	_prettyRegExp(regexString, stripSlash = true) {
-		const str = (regexString + "").replace(/!/g, "%21").replace(/\|/g, "%7C");
-		return stripSlash ? str.substring(1, str.length - 1) : str;
+		const str = stripSlash
+			? regexString.source + regexString.flags
+			: regexString + "";
+		return str.replace(/!/g, "%21").replace(/\|/g, "%7C");
 	}
 
 	_createIdentifier() {

package/lib/DefinePlugin.js

@@ -272,7 +272,7 @@ const toCode = (
 
 	const strCode = transformToCode();
 
-	logger.log(`Replaced "${key}" with "${strCode}"`);
+	logger.debug(`Replaced "${key}" with "${strCode}"`);
 
 	return strCode;
 };

package/lib/NormalModule.js

@@ -867,9 +867,14 @@ class NormalModule extends Module {
 				return callback(error);
 			}
 
+			const isBinaryModule =
+				this.generatorOptions && this.generatorOptions.binary !== undefined
+					? this.generatorOptions.binary
+					: this.binary;
+
 			this._source = this.createSource(
 				/** @type {string} */ (options.context),
-				this.binary ? asBuffer(source) : asString(source),
+				isBinaryModule ? asBuffer(source) : asString(source),
 				sourceMap,
 				compilation.compiler.root
 			);

package/lib/UseStrictPlugin.js

@@ -12,6 +12,7 @@ const {
 } = require("./ModuleTypeConstants");
 const ConstDependency = require("./dependencies/ConstDependency");
 
+/** @typedef {import("../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("./Compiler")} Compiler */
 /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
@@ -32,8 +33,9 @@ class UseStrictPlugin {
 			(compilation, { normalModuleFactory }) => {
 				/**
 				 * @param {JavascriptParser} parser the parser
+				 * @param {JavascriptParserOptions} parserOptions the javascript parser options
 				 */
-				const handler = parser => {
+				const handler = (parser, parserOptions) => {
 					parser.hooks.program.tap(PLUGIN_NAME, ast => {
 						const firstNode = ast.body[0];
 						if (
@@ -54,6 +56,11 @@ class UseStrictPlugin {
 							/** @type {BuildInfo} */
 							(parser.state.module.buildInfo).strict = true;
 						}
+						if (parserOptions.overrideStrict) {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).strict =
+								parserOptions.overrideStrict === "strict";
+						}
 					});
 				};
 

package/lib/WebpackOptionsApply.js

@@ -286,6 +286,11 @@ class WebpackOptionsApply extends OptionsApply {
 					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
 				);
 			}
+			if (options.output.enabledLibraryTypes.includes("modern-module")) {
+				throw new Error(
+					"library type \"modern-module\" is only allowed when 'experiments.outputModule' is enabled"
+				);
+			}
 			if (options.externalsType === "module") {
 				throw new Error(
 					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"

package/lib/css/CssExportsGenerator.js

@@ -10,7 +10,6 @@ const { UsageState } = require("../ExportsInfo");
 const Generator = require("../Generator");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
-const { cssExportConvention } = require("../util/conventions");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
@@ -135,20 +134,18 @@ class CssExportsGenerator extends Generator {
 			const source = new ConcatSource();
 			const usedIdentifiers = new Set();
 			for (const [name, v] of cssExportsData.exports) {
-				for (let k of cssExportConvention(name, this.convention)) {
-					let identifier = Template.toIdentifier(k);
-					let i = 0;
-					while (usedIdentifiers.has(identifier)) {
-						identifier = Template.toIdentifier(k + i);
-					}
-					usedIdentifiers.add(identifier);
-					generateContext.concatenationScope.registerExport(k, identifier);
-					source.add(
-						`${
-							generateContext.runtimeTemplate.supportsConst() ? "const" : "var"
-						} ${identifier} = ${JSON.stringify(v)};\n`
-					);
+				let identifier = Template.toIdentifier(name);
+				let i = 0;
+				while (usedIdentifiers.has(identifier)) {
+					identifier = Template.toIdentifier(name + i);
 				}
+				usedIdentifiers.add(identifier);
+				generateContext.concatenationScope.registerExport(name, identifier);
+				source.add(
+					`${
+						generateContext.runtimeTemplate.supportsConst() ? "const" : "var"
+					} ${identifier} = ${JSON.stringify(v)};\n`
+				);
 			}
 			return source;
 		} else {
@@ -163,16 +160,14 @@ class CssExportsGenerator extends Generator {
 					RuntimeGlobals.makeNamespaceObject
 				);
 			}
-			const newExports = [];
-			for (let [k, v] of cssExportsData.exports) {
-				for (let name of cssExportConvention(k, this.convention)) {
-					newExports.push(`\t${JSON.stringify(name)}: ${JSON.stringify(v)}`);
-				}
+			const exports = [];
+			for (let [name, v] of cssExportsData.exports) {
+				exports.push(`\t${JSON.stringify(name)}: ${JSON.stringify(v)}`);
 			}
 			return new RawSource(
 				`${needNsObj ? `${RuntimeGlobals.makeNamespaceObject}(` : ""}${
 					module.moduleArgument
-				}.exports = {\n${newExports.join(",\n")}\n}${needNsObj ? ")" : ""};`
+				}.exports = {\n${exports.join(",\n")}\n}${needNsObj ? ")" : ""};`
 			);
 		}
 	}
@@ -198,7 +193,9 @@ class CssExportsGenerator extends Generator {
 	 * @param {Hash} hash hash that will be modified
 	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
-	updateHash(hash, { module }) {}
+	updateHash(hash, { module }) {
+		hash.update(this.esModule.toString());
+	}
 }
 
 module.exports = CssExportsGenerator;

package/lib/css/CssGenerator.js

@@ -9,7 +9,6 @@ const { ReplaceSource } = require("webpack-sources");
 const Generator = require("../Generator");
 const InitFragment = require("../InitFragment");
 const RuntimeGlobals = require("../RuntimeGlobals");
-const { cssExportConvention } = require("../util/conventions");
 
 /** @typedef {import("webpack-sources").Source} Source */
 /** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
@@ -106,15 +105,6 @@ class CssGenerator extends Generator {
 		if (module.presentationalDependencies !== undefined)
 			module.presentationalDependencies.forEach(handleDependency);
 
-		if (cssExportsData.exports.size > 0) {
-			const newExports = new Map();
-			for (let [name, v] of cssExportsData.exports) {
-				for (let newName of cssExportConvention(name, this.convention)) {
-					newExports.set(newName, v);
-				}
-			}
-			cssExportsData.exports = newExports;
-		}
 		const data = generateContext.getData();
 		data.set("css-exports", cssExportsData);
 
@@ -148,7 +138,9 @@ class CssGenerator extends Generator {
 	 * @param {Hash} hash hash that will be modified
 	 * @param {UpdateHashContext} updateHashContext context for updating hash
 	 */
-	updateHash(hash, { module }) {}
+	updateHash(hash, { module }) {
+		hash.update(this.esModule.toString());
+	}
 }
 
 module.exports = CssGenerator;

package/lib/dependencies/CssExportDependency.js

@@ -5,16 +5,23 @@
 
 "use strict";
 
+const { cssExportConvention } = require("../util/conventions");
 const makeSerializable = require("../util/makeSerializable");
 const NullDependency = require("./NullDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../../declarations/WebpackOptions").CssGeneratorExportsConvention} CssGeneratorExportsConvention */
+/** @typedef {import("../CssModule")} CssModule */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../css/CssExportsGenerator")} CssExportsGenerator */
+/** @typedef {import("../css/CssGenerator")} CssGenerator */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
 
 class CssExportDependency extends NullDependency {
 	/**
@@ -31,24 +38,60 @@ class CssExportDependency extends NullDependency {
 		return "css :export";
 	}
 
+	/**
+	 * @param {string} name export name
+	 * @param {CssGeneratorExportsConvention} convention convention of the export name
+	 * @returns {string[]} convention results
+	 */
+	getExportsConventionNames(name, convention) {
+		if (this._conventionNames) {
+			return this._conventionNames;
+		}
+		this._conventionNames = cssExportConvention(name, convention);
+		return this._conventionNames;
+	}
+
 	/**
 	 * Returns the exported names
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {ExportsSpec | undefined} export names
 	 */
 	getExports(moduleGraph) {
-		const name = this.name;
+		const module = /** @type {CssModule} */ (moduleGraph.getParentModule(this));
+		const convention = /** @type {CssGenerator | CssExportsGenerator} */ (
+			module.generator
+		).convention;
+		const names = this.getExportsConventionNames(this.name, convention);
 		return {
-			exports: [
-				{
-					name,
-					canMangle: true
-				}
-			],
+			exports: names.map(name => ({
+				name,
+				canMangle: true
+			})),
 			dependencies: undefined
 		};
 	}
 
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, { chunkGraph }) {
+		const module = /** @type {CssModule} */ (
+			chunkGraph.moduleGraph.getParentModule(this)
+		);
+		const generator = /** @type {CssGenerator | CssExportsGenerator} */ (
+			module.generator
+		);
+		const names = this.getExportsConventionNames(
+			this.name,
+			generator.convention
+		);
+		hash.update(`exportsConvention`);
+		hash.update(JSON.stringify(names));
+	}
+
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -79,9 +122,29 @@ CssExportDependency.Template = class CssExportDependencyTemplate extends (
 	 * @param {DependencyTemplateContext} templateContext the context object
 	 * @returns {void}
 	 */
-	apply(dependency, source, { cssExportsData }) {
+	apply(
+		dependency,
+		source,
+		{ cssExportsData, module: m, runtime, moduleGraph }
+	) {
 		const dep = /** @type {CssExportDependency} */ (dependency);
-		cssExportsData.exports.set(dep.name, dep.value);
+		const module = /** @type {CssModule} */ (m);
+		const convention = /** @type {CssGenerator | CssExportsGenerator} */ (
+			module.generator
+		).convention;
+		const names = dep.getExportsConventionNames(dep.name, convention);
+		const usedNames = /** @type {string[]} */ (
+			names
+				.map(name =>
+					moduleGraph.getExportInfo(module, name).getUsedName(name, runtime)
+				)
+				.filter(Boolean)
+		);
+		if (usedNames.length === 0) return;
+
+		for (const used of usedNames) {
+			cssExportsData.exports.set(used, dep.value);
+		}
 	}
 };
 

package/lib/dependencies/CssLocalIdentifierDependency.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { cssExportConvention } = require("../util/conventions");
 const createHash = require("../util/createHash");
 const { makePathsRelative } = require("../util/identifier");
 const makeSerializable = require("../util/makeSerializable");
@@ -17,6 +18,7 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../CssModule")} CssModule */
 /** @typedef {import("../Dependency")} Dependency */
 /** @typedef {import("../Dependency").ExportsSpec} ExportsSpec */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").CssDependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
@@ -25,6 +27,7 @@ const NullDependency = require("./NullDependency");
 /** @typedef {import("../css/CssParser").Range} Range */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
 
 /**
  * @param {string} local css local
@@ -88,24 +91,62 @@ class CssLocalIdentifierDependency extends NullDependency {
 		return "css local identifier";
 	}
 
+	/**
+	 * @param {string} name export name
+	 * @param {CssGeneratorExportsConvention} convention convention of the export name
+	 * @returns {string[]} convention results
+	 */
+	getExportsConventionNames(name, convention) {
+		if (this._conventionNames) {
+			return this._conventionNames;
+		}
+		this._conventionNames = cssExportConvention(this.name, convention);
+		return this._conventionNames;
+	}
+
 	/**
 	 * Returns the exported names
 	 * @param {ModuleGraph} moduleGraph module graph
 	 * @returns {ExportsSpec | undefined} export names
 	 */
 	getExports(moduleGraph) {
-		const name = this.name;
+		const module = /** @type {CssModule} */ (moduleGraph.getParentModule(this));
+		const convention = /** @type {CssGenerator | CssExportsGenerator} */ (
+			module.generator
+		).convention;
+		const names = this.getExportsConventionNames(this.name, convention);
 		return {
-			exports: [
-				{
-					name,
-					canMangle: true
-				}
-			],
+			exports: names.map(name => ({
+				name,
+				canMangle: true
+			})),
 			dependencies: undefined
 		};
 	}
 
+	/**
+	 * Update the hash
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, { chunkGraph }) {
+		const module = /** @type {CssModule} */ (
+			chunkGraph.moduleGraph.getParentModule(this)
+		);
+		const generator = /** @type {CssGenerator | CssExportsGenerator} */ (
+			module.generator
+		);
+		const names = this.getExportsConventionNames(
+			this.name,
+			generator.convention
+		);
+		hash.update(`exportsConvention`);
+		hash.update(JSON.stringify(names));
+		hash.update(`localIdentName`);
+		hash.update(generator.localIdentName);
+	}
+
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -158,7 +199,7 @@ CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTempla
 		dependency,
 		source,
 		{
-			module,
+			module: m,
 			moduleGraph,
 			chunkGraph,
 			runtime,
@@ -167,26 +208,32 @@ CssLocalIdentifierDependency.Template = class CssLocalIdentifierDependencyTempla
 		}
 	) {
 		const dep = /** @type {CssLocalIdentifierDependency} */ (dependency);
-		const used = moduleGraph
-			.getExportInfo(module, dep.name)
-			.getUsedName(dep.name, runtime);
-
-		if (!used) return;
+		const module = /** @type {CssModule} */ (m);
+		const convention = /** @type {CssGenerator | CssExportsGenerator} */ (
+			module.generator
+		).convention;
+		const names = dep.getExportsConventionNames(dep.name, convention);
+		const usedNames = /** @type {string[]} */ (
+			names
+				.map(name =>
+					moduleGraph.getExportInfo(module, name).getUsedName(name, runtime)
+				)
+				.filter(Boolean)
+		);
+		if (usedNames.length === 0) return;
 
+		// use the first usedName to generate localIdent, it's shorter when mangle exports enabled
 		const localIdent =
 			dep.prefix +
-			getLocalIdent(
-				used,
-				/** @type {CssModule} */ (module),
-				chunkGraph,
-				runtimeTemplate
-			);
+			getLocalIdent(usedNames[0], module, chunkGraph, runtimeTemplate);
 		source.replace(
 			dep.range[0],
 			dep.range[1] - 1,
 			escapeCssIdentifier(localIdent, dep.prefix)
 		);
-		if (used) cssExportsData.exports.set(used, localIdent);
+		for (const used of usedNames) {
+			cssExportsData.exports.set(used, localIdent);
+		}
 	}
 };
 

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -344,13 +344,13 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 		}
 
 		if (dep.referencedPropertiesInDestructuring) {
+			const prefixedIds = ids[0] === "default" ? ids.slice(1) : ids;
 			for (let {
 				id,
 				shorthand,
 				range
 			} of dep.referencedPropertiesInDestructuring) {
-				const concatedIds = ids.concat([id]);
-				if (concatedIds[0] === "default") concatedIds.shift();
+				const concatedIds = prefixedIds.concat([id]);
 				const module = moduleGraph.getModule(dep);
 				const used = moduleGraph
 					.getExportsInfo(module)

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -16,6 +16,7 @@ const {
 	getChunkFilenameTemplate
 } = require("../javascript/JavascriptModulesPlugin");
 const { updateHashForEntryStartup } = require("../javascript/StartupHelpers");
+const { getUndoPath } = require("../util/identifier");
 
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
@@ -86,11 +87,9 @@ class ModuleChunkFormatPlugin {
 											contentHashType: "javascript"
 										}
 									)
+									.replace(/^\/+/g, "")
 									.split("/");
 
-								// remove filename, we only need the directory
-								currentOutputName.pop();
-
 								/**
 								 * @param {Chunk} chunk the chunk
 								 * @returns {string} the relative path
@@ -108,22 +107,22 @@ class ModuleChunkFormatPlugin {
 												contentHashType: "javascript"
 											}
 										)
+										.replace(/^\/+/g, "")
 										.split("/");
 
-									// remove common parts
+									// remove common parts except filename
 									while (
-										baseOutputName.length > 0 &&
-										chunkOutputName.length > 0 &&
+										baseOutputName.length > 1 &&
+										chunkOutputName.length > 1 &&
 										baseOutputName[0] === chunkOutputName[0]
 									) {
 										baseOutputName.shift();
 										chunkOutputName.shift();
 									}
+									const last = chunkOutputName.join("/");
 									// create final path
 									return (
-										(baseOutputName.length > 0
-											? "../".repeat(baseOutputName.length)
-											: "./") + chunkOutputName.join("/")
+										getUndoPath(baseOutputName.join("/"), last, true) + last
 									);
 								};
 

package/lib/javascript/ArrayPushCallbackChunkFormatPlugin.js

@@ -33,6 +33,7 @@ class ArrayPushCallbackChunkFormatPlugin {
 						if (chunk.hasRuntime()) return;
 						if (chunkGraph.getNumberOfEntryModules(chunk) > 0) {
 							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.exports);
 							set.add(RuntimeGlobals.require);
 						}
 						set.add(RuntimeGlobals.chunkCallback);

package/lib/javascript/CommonJsChunkFormatPlugin.js

@@ -8,6 +8,7 @@
 const { ConcatSource, RawSource } = require("webpack-sources");
 const RuntimeGlobals = require("../RuntimeGlobals");
 const Template = require("../Template");
+const { getUndoPath } = require("../util/identifier");
 const {
 	getChunkFilenameTemplate,
 	getCompilationHooks
@@ -79,6 +80,7 @@ class CommonJsChunkFormatPlugin {
 										contentHashType: "javascript"
 									}
 								)
+								.replace(/^\/+/g, "")
 								.split("/");
 							const runtimeOutputName = compilation
 								.getPath(
@@ -91,26 +93,22 @@ class CommonJsChunkFormatPlugin {
 										contentHashType: "javascript"
 									}
 								)
+								.replace(/^\/+/g, "")
 								.split("/");
 
-							// remove filename, we only need the directory
-							currentOutputName.pop();
-
 							// remove common parts
 							while (
-								currentOutputName.length > 0 &&
-								runtimeOutputName.length > 0 &&
+								currentOutputName.length > 1 &&
+								runtimeOutputName.length > 1 &&
 								currentOutputName[0] === runtimeOutputName[0]
 							) {
 								currentOutputName.shift();
 								runtimeOutputName.shift();
 							}
-
+							const last = runtimeOutputName.join("/");
 							// create final path
 							const runtimePath =
-								(currentOutputName.length > 0
-									? "../".repeat(currentOutputName.length)
-									: "./") + runtimeOutputName.join("/");
+								getUndoPath(currentOutputName.join("/"), last, true) + last;
 
 							const entrySource = new ConcatSource();
 							entrySource.add(

package/lib/javascript/JavascriptModulesPlugin.js

@@ -435,6 +435,7 @@ class JavascriptModulesPlugin {
 							chunkGraph.hasChunkEntryDependentChunks(chunk)
 						) {
 							set.add(RuntimeGlobals.onChunksLoaded);
+							set.add(RuntimeGlobals.exports);
 							set.add(RuntimeGlobals.require);
 						}
 					}
@@ -821,7 +822,11 @@ class JavascriptModulesPlugin {
 			}
 			const lastInlinedModule = last(inlinedModules);
 			const startupSource = new ConcatSource();
-			startupSource.add(`var ${RuntimeGlobals.exports} = {};\n`);
+
+			if (runtimeRequirements.has(RuntimeGlobals.exports)) {
+				startupSource.add(`var ${RuntimeGlobals.exports} = {};\n`);
+			}
+
 			const renamedInlinedModule = this.renameInlineModule(
 				allModules,
 				renderContext,

package/lib/library/AssignLibraryPlugin.js

@@ -356,7 +356,7 @@ class AssignLibraryPlugin extends AbstractLibraryPlugin {
 	 * @returns {void}
 	 */
 	runtimeRequirements(chunk, set, libraryContext) {
-		// we don't need to return exports from runtime
+		set.add(RuntimeGlobals.exports);
 	}
 
 	/**

package/lib/library/EnableLibraryPlugin.js

@@ -78,7 +78,8 @@ class EnableLibraryPlugin {
 				const ExportPropertyTemplatePlugin = require("./ExportPropertyLibraryPlugin");
 				new ExportPropertyTemplatePlugin({
 					type,
-					nsObjectUsed: type !== "module"
+					nsObjectUsed: !["module", "modern-module"].includes(type),
+					runtimeExportsUsed: type !== "modern-module"
 				}).apply(compiler);
 			};
 			switch (type) {
@@ -238,6 +239,14 @@ 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.`);