webpack 5.66.0 → 5.69.1

package/lib/css/CssModulesPlugin.js

@@ -19,10 +19,13 @@ const { compareModulesByIdentifier } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
 const memoize = require("../util/memoize");
+const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
+const CssExportsGenerator = require("./CssExportsGenerator");
 const CssGenerator = require("./CssGenerator");
 const CssParser = require("./CssParser");
 
 /** @typedef {import("webpack-sources").Source} Source */
+/** @typedef {import("../../declarations/WebpackOptions").CssExperimentOptions} CssExperimentOptions */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Module")} Module */
@@ -70,6 +73,12 @@ const escapeCss = (str, omitOptionalUnderscore) => {
 const plugin = "CssModulesPlugin";
 
 class CssModulesPlugin {
+	/**
+	 * @param {CssExperimentOptions} options options
+	 */
+	constructor({ exportsOnly = false }) {
+		this._exportsOnly = exportsOnly;
+	}
 	/**
 	 * Apply the plugin
 	 * @param {Compiler} compiler the compiler instance
@@ -143,19 +152,25 @@ class CssModulesPlugin {
 					.for("css")
 					.tap(plugin, generatorOptions => {
 						validateGeneratorOptions(generatorOptions);
-						return new CssGenerator();
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
 					});
 				normalModuleFactory.hooks.createGenerator
 					.for("css/global")
 					.tap(plugin, generatorOptions => {
 						validateGeneratorOptions(generatorOptions);
-						return new CssGenerator();
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
 					});
 				normalModuleFactory.hooks.createGenerator
 					.for("css/module")
 					.tap(plugin, generatorOptions => {
 						validateGeneratorOptions(generatorOptions);
-						return new CssGenerator();
+						return this._exportsOnly
+							? new CssExportsGenerator()
+							: new CssGenerator();
 					});
 				const orderedCssModulesPerChunk = new WeakMap();
 				compilation.hooks.afterCodeGeneration.tap("CssModulesPlugin", () => {
@@ -187,7 +202,7 @@ class CssModulesPlugin {
 						hash.update(chunkGraph.getModuleHash(module, chunk.runtime));
 					}
 					const digest = /** @type {string} */ (hash.digest(hashDigest));
-					chunk.contentHash.css = digest.substr(0, hashDigestLength);
+					chunk.contentHash.css = nonNumericOnlyHash(digest, hashDigestLength);
 				});
 				compilation.hooks.renderManifest.tap(plugin, (result, options) => {
 					const { chunkGraph } = compilation;
@@ -238,6 +253,9 @@ class CssModulesPlugin {
 					const CssLoadingRuntimeModule = getCssLoadingRuntimeModule();
 					compilation.addRuntimeModule(chunk, new CssLoadingRuntimeModule(set));
 				};
+				compilation.hooks.runtimeRequirementInTree
+					.for(RuntimeGlobals.hasCssModules)
+					.tap(plugin, handler);
 				compilation.hooks.runtimeRequirementInTree
 					.for(RuntimeGlobals.ensureChunkHandlers)
 					.tap(plugin, handler);

package/lib/debug/ProfilingPlugin.js

@@ -123,9 +123,7 @@ class Profiler {
  * @returns {Trace} The trace object
  */
 const createTrace = (fs, outputPath) => {
-	const trace = new Tracer({
-		noStream: true
-	});
+	const trace = new Tracer();
 	const profiler = new Profiler(inspector);
 	if (/\/|\\/.test(outputPath)) {
 		const dirPath = dirname(fs, outputPath);
@@ -173,6 +171,7 @@ const createTrace = (fs, outputPath) => {
 		counter,
 		profiler,
 		end: callback => {
+			trace.push("]");
 			// Wait until the write stream finishes.
 			fsStream.on("close", () => {
 				callback();
@@ -242,10 +241,10 @@ class ProfilingPlugin {
 				stage: Infinity
 			},
 			(stats, callback) => {
+				if (compiler.watchMode) return callback();
 				tracer.profiler.stopProfiling().then(parsedResults => {
 					if (parsedResults === undefined) {
 						tracer.profiler.destroy();
-						tracer.trace.flush();
 						tracer.end(callback);
 						return;
 					}
@@ -293,7 +292,6 @@ class ProfilingPlugin {
 					});
 
 					tracer.profiler.destroy();
-					tracer.trace.flush();
 					tracer.end(callback);
 				});
 			}
@@ -345,16 +343,19 @@ const interceptAllJavascriptModulesPluginHooks = (compilation, tracer) => {
 };
 
 const makeInterceptorFor = (instance, tracer) => hookName => ({
-	register: ({ name, type, context, fn }) => {
-		const newFn = makeNewProfiledTapFn(hookName, tracer, {
-			name,
-			type,
-			fn
-		});
+	register: tapInfo => {
+		const { name, type, fn } = tapInfo;
+		const newFn =
+			// Don't tap our own hooks to ensure stream can close cleanly
+			name === pluginName
+				? fn
+				: makeNewProfiledTapFn(hookName, tracer, {
+						name,
+						type,
+						fn
+				  });
 		return {
-			name,
-			type,
-			context,
+			...tapInfo,
 			fn: newFn
 		};
 	}

package/lib/dependencies/ContextElementDependency.js

@@ -53,12 +53,18 @@ class ContextElementDependency extends ModuleDependency {
 	}
 
 	serialize(context) {
-		context.write(this.referencedExports);
+		const { write } = context;
+		write(this._typePrefix);
+		write(this._category);
+		write(this.referencedExports);
 		super.serialize(context);
 	}
 
 	deserialize(context) {
-		this.referencedExports = context.read();
+		const { read } = context;
+		this._typePrefix = read();
+		this._category = read();
+		this.referencedExports = read();
 		super.deserialize(context);
 	}
 }

package/lib/dependencies/CreateScriptUrlDependency.js

@@ -25,6 +25,18 @@ class CreateScriptUrlDependency extends NullDependency {
 	get type() {
 		return "create script url";
 	}
+
+	serialize(context) {
+		const { write } = context;
+		write(this.range);
+		super.serialize(context);
+	}
+
+	deserialize(context) {
+		const { read } = context;
+		this.range = read();
+		super.deserialize(context);
+	}
 }
 
 CreateScriptUrlDependency.Template = class CreateScriptUrlDependencyTemplate extends (

package/lib/dependencies/ExportsInfoDependency.js

@@ -46,6 +46,12 @@ const getProperty = (moduleGraph, module, exportName, property, runtime) => {
 		}
 	}
 	switch (property) {
+		case "canMangle": {
+			const exportsInfo = moduleGraph.getExportsInfo(module);
+			const exportInfo = exportsInfo.getExportInfo(exportName);
+			if (exportInfo) return exportInfo.canMangle;
+			return exportsInfo.otherExportsInfo.canMangle;
+		}
 		case "used":
 			return (
 				moduleGraph.getExportsInfo(module).getUsed(exportName, runtime) !==

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -74,14 +74,14 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 			initFragments.push(
 				new InitFragment(
 					runtimeTemplate.supportsArrowFunction()
-						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__) => {\n`
-						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__) {\n`,
+						? `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {\n`
+						: `${RuntimeGlobals.asyncModule}(${module.moduleArgument}, async function (__webpack_handle_async_dependencies__, __webpack_async_result__) { try {\n`,
 					InitFragment.STAGE_ASYNC_BOUNDARY,
 					0,
 					undefined,
-					module.buildMeta.async
-						? `\n__webpack_handle_async_dependencies__();\n}, 1);`
-						: "\n});"
+					`\n__webpack_async_result__();\n} catch(e) { __webpack_async_result__(e); } }${
+						module.buildMeta.async ? ", 1" : ""
+					});`
 				)
 			);
 		}

package/lib/dependencies/ImportMetaPlugin.js

@@ -20,6 +20,7 @@ const propertyAccess = require("../util/propertyAccess");
 const ConstDependency = require("./ConstDependency");
 
 /** @typedef {import("estree").MemberExpression} MemberExpression */
+/** @typedef {import("../../declarations/WebpackOptions").JavascriptParserOptions} JavascriptParserOptions */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../javascript/JavascriptParser")} Parser */
@@ -44,11 +45,29 @@ class ImportMetaPlugin {
 					return pathToFileURL(module.resource).toString();
 				};
 				/**
-				 * @param {Parser} parser parser
-				 * @param {Object} parserOptions parserOptions
+				 * @param {Parser} parser parser parser
+				 * @param {JavascriptParserOptions} parserOptions parserOptions
 				 * @returns {void}
 				 */
-				const parserHandler = (parser, parserOptions) => {
+				const parserHandler = (parser, { importMeta }) => {
+					if (importMeta === false) {
+						const { importMetaName } = compilation.outputOptions;
+						if (importMetaName === "import.meta") return;
+
+						parser.hooks.expression
+							.for("import.meta")
+							.tap("ImportMetaPlugin", metaProperty => {
+								const dep = new ConstDependency(
+									importMetaName,
+									metaProperty.range
+								);
+								dep.loc = metaProperty.loc;
+								parser.state.module.addPresentationalDependency(dep);
+								return true;
+							});
+						return;
+					}
+
 					/// import.meta direct ///
 					parser.hooks.typeof
 						.for("import.meta")

package/lib/dependencies/LoaderPlugin.js

@@ -16,7 +16,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
 
 /**
  * @callback LoadModuleCallback
- * @param {Error=} err error object
+ * @param {(Error | null)=} err error object
  * @param {string | Buffer=} source source code
  * @param {object=} map source map
  * @param {Module=} module loaded module if successful
@@ -24,7 +24,7 @@ const LoaderImportDependency = require("./LoaderImportDependency");
 
 /**
  * @callback ImportModuleCallback
- * @param {Error=} err error object
+ * @param {(Error | null)=} err error object
  * @param {any=} exports exports of the evaluated module
  */
 

package/lib/hmr/LazyCompilationPlugin.js

@@ -29,6 +29,7 @@ const { registerNotSerializable } = require("../util/serialization");
 /** @typedef {import("../RequestShortener")} RequestShortener */
 /** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
 /** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
 
@@ -38,7 +39,7 @@ const { registerNotSerializable } = require("../util/serialization");
  * @property {function(Module): { client: string, data: string, active: boolean }} module
  */
 
-const IGNORED_DEPENDENCY_TYPES = new Set([
+const HMR_DEPENDENCY_TYPES = new Set([
 	"import.meta.webpackHot.accept",
 	"import.meta.webpackHot.decline",
 	"module.hot.accept",
@@ -146,7 +147,7 @@ class LazyCompilationProxyModule extends Module {
 
 	/**
 	 * @param {NeedBuildContext} context context info
-	 * @param {function(WebpackError=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
 	 */
 	needBuild(context, callback) {
@@ -351,32 +352,55 @@ class LazyCompilationPlugin {
 					"LazyCompilationPlugin",
 					(originalModule, createData, resolveData) => {
 						if (
-							resolveData.dependencies.every(
+							resolveData.dependencies.every(dep =>
+								HMR_DEPENDENCY_TYPES.has(dep.type)
+							)
+						) {
+							// for HMR only resolving, try to determine if the HMR accept/decline refers to
+							// an import() or not
+							const hmrDep = resolveData.dependencies[0];
+							const originModule =
+								compilation.moduleGraph.getParentModule(hmrDep);
+							const isReferringToDynamicImport = originModule.blocks.some(
+								block =>
+									block.dependencies.some(
+										dep =>
+											dep.type === "import()" &&
+											/** @type {HarmonyImportDependency} */ (dep).request ===
+												hmrDep.request
+									)
+							);
+							if (!isReferringToDynamicImport) return;
+						} else if (
+							!resolveData.dependencies.every(
 								dep =>
-									IGNORED_DEPENDENCY_TYPES.has(dep.type) ||
+									HMR_DEPENDENCY_TYPES.has(dep.type) ||
 									(this.imports &&
 										(dep.type === "import()" ||
 											dep.type === "import() context element")) ||
 									(this.entries && dep.type === "entry")
-							) &&
-							!/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client/.test(
+							)
+						)
+							return;
+						if (
+							/webpack[/\\]hot[/\\]|webpack-dev-server[/\\]client|webpack-hot-middleware[/\\]client/.test(
 								resolveData.request
-							) &&
-							checkTest(this.test, originalModule)
-						) {
-							const moduleInfo = backend.module(originalModule);
-							if (!moduleInfo) return;
-							const { client, data, active } = moduleInfo;
+							) ||
+							!checkTest(this.test, originalModule)
+						)
+							return;
+						const moduleInfo = backend.module(originalModule);
+						if (!moduleInfo) return;
+						const { client, data, active } = moduleInfo;
 
-							return new LazyCompilationProxyModule(
-								compiler.context,
-								originalModule,
-								resolveData.request,
-								client,
-								data,
-								active
-							);
-						}
+						return new LazyCompilationProxyModule(
+							compiler.context,
+							originalModule,
+							resolveData.request,
+							client,
+							data,
+							active
+						);
 					}
 				);
 				compilation.dependencyFactories.set(

package/lib/hmr/lazyCompilationBackend.js

@@ -13,7 +13,7 @@
 /**
  * @callback BackendHandler
  * @param {Compiler} compiler compiler
- * @param {function(Error?, any?): void} callback callback
+ * @param {function((Error | null)=, any=): void} callback callback
  * @returns {void}
  */
 

package/lib/ids/DeterministicModuleIdsPlugin.js

@@ -9,7 +9,7 @@ const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const {
-	getUsedModuleIds,
+	getUsedModuleIdsAndModules,
 	getFullModuleName,
 	assignDeterministicIds
 } = require("./IdHelpers");
@@ -18,8 +18,17 @@ const {
 /** @typedef {import("../Module")} Module */
 
 class DeterministicModuleIdsPlugin {
-	constructor(options) {
-		this.options = options || {};
+	/**
+	 * @param {Object} options options
+	 * @param {string=} options.context context relative to which module identifiers are computed
+	 * @param {function(Module): boolean=} options.test selector function for modules
+	 * @param {number=} options.maxLength maximum id length in digits (used as starting point)
+	 * @param {number=} options.salt hash salt for ids
+	 * @param {boolean=} options.fixedLength do not increase the maxLength to find an optimal id space size
+	 * @param {boolean=} options.failOnConflict throw an error when id conflicts occur (instead of rehashing)
+	 */
+	constructor(options = {}) {
+		this.options = options;
 	}
 
 	/**
@@ -31,40 +40,51 @@ class DeterministicModuleIdsPlugin {
 		compiler.hooks.compilation.tap(
 			"DeterministicModuleIdsPlugin",
 			compilation => {
-				compilation.hooks.moduleIds.tap(
-					"DeterministicModuleIdsPlugin",
-					modules => {
-						const chunkGraph = compilation.chunkGraph;
-						const context = this.options.context
-							? this.options.context
-							: compiler.context;
-						const maxLength = this.options.maxLength || 3;
+				compilation.hooks.moduleIds.tap("DeterministicModuleIdsPlugin", () => {
+					const chunkGraph = compilation.chunkGraph;
+					const context = this.options.context
+						? this.options.context
+						: compiler.context;
+					const maxLength = this.options.maxLength || 3;
+					const failOnConflict = this.options.failOnConflict || false;
+					const fixedLength = this.options.fixedLength || false;
+					const salt = this.options.salt || 0;
+					let conflicts = 0;
 
-						const usedIds = getUsedModuleIds(compilation);
-						assignDeterministicIds(
-							Array.from(modules).filter(module => {
-								if (!module.needId) return false;
-								if (chunkGraph.getNumberOfModuleChunks(module) === 0)
-									return false;
-								return chunkGraph.getModuleId(module) === null;
-							}),
-							module => getFullModuleName(module, context, compiler.root),
-							compareModulesByPreOrderIndexOrIdentifier(
-								compilation.moduleGraph
-							),
-							(module, id) => {
-								const size = usedIds.size;
-								usedIds.add(`${id}`);
-								if (size === usedIds.size) return false;
-								chunkGraph.setModuleId(module, id);
-								return true;
-							},
-							[Math.pow(10, maxLength)],
-							10,
-							usedIds.size
+					const [usedIds, modules] = getUsedModuleIdsAndModules(
+						compilation,
+						this.options.test
+					);
+					assignDeterministicIds(
+						modules,
+						module => getFullModuleName(module, context, compiler.root),
+						failOnConflict
+							? () => 0
+							: compareModulesByPreOrderIndexOrIdentifier(
+									compilation.moduleGraph
+							  ),
+						(module, id) => {
+							const size = usedIds.size;
+							usedIds.add(`${id}`);
+							if (size === usedIds.size) {
+								conflicts++;
+								return false;
+							}
+							chunkGraph.setModuleId(module, id);
+							return true;
+						},
+						[Math.pow(10, maxLength)],
+						fixedLength ? 0 : 10,
+						usedIds.size,
+						salt
+					);
+					if (failOnConflict && conflicts)
+						throw new Error(
+							`Assigning deterministic module ids has lead to ${conflicts} conflict${
+								conflicts > 1 ? "s" : ""
+							}.\nIncrease the 'maxLength' to increase the id space and make conflicts less likely (recommended when there are many conflicts or application is expected to grow), or add an 'salt' number to try another hash starting value in the same id space (recommended when there is only a single conflict).`
 						);
-					}
-				);
+				});
 			}
 		);
 	}

package/lib/ids/HashedModuleIdsPlugin.js

@@ -10,7 +10,10 @@ const {
 } = require("../util/comparators");
 const createSchemaValidation = require("../util/create-schema-validation");
 const createHash = require("../util/createHash");
-const { getUsedModuleIds, getFullModuleName } = require("./IdHelpers");
+const {
+	getUsedModuleIdsAndModules,
+	getFullModuleName
+} = require("./IdHelpers");
 
 /** @typedef {import("../../declarations/plugins/HashedModuleIdsPlugin").HashedModuleIdsPluginOptions} HashedModuleIdsPluginOptions */
 
@@ -43,22 +46,16 @@ class HashedModuleIdsPlugin {
 	apply(compiler) {
 		const options = this.options;
 		compiler.hooks.compilation.tap("HashedModuleIdsPlugin", compilation => {
-			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", modules => {
+			compilation.hooks.moduleIds.tap("HashedModuleIdsPlugin", () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
 					? this.options.context
 					: compiler.context;
 
-				const usedIds = getUsedModuleIds(compilation);
-				const modulesInNaturalOrder = Array.from(modules)
-					.filter(m => {
-						if (!m.needId) return false;
-						if (chunkGraph.getNumberOfModuleChunks(m) === 0) return false;
-						return chunkGraph.getModuleId(module) === null;
-					})
-					.sort(
-						compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
-					);
+				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);
+				const modulesInNaturalOrder = modules.sort(
+					compareModulesByPreOrderIndexOrIdentifier(compilation.moduleGraph)
+				);
 				for (const module of modulesInNaturalOrder) {
 					const ident = getFullModuleName(module, context, compiler.root);
 					const hash = createHash(options.hashFunction);

package/lib/ids/IdHelpers.js

@@ -234,11 +234,14 @@ const addToMapOfItems = (map, key, value) => {
 
 /**
  * @param {Compilation} compilation the compilation
- * @returns {Set<string>} used module ids as strings
+ * @param {function(Module): boolean=} filter filter modules
+ * @returns {[Set<string>, Module[]]} used module ids as strings and modules without id matching the filter
  */
-const getUsedModuleIds = compilation => {
+const getUsedModuleIdsAndModules = (compilation, filter) => {
 	const chunkGraph = compilation.chunkGraph;
 
+	const modules = [];
+
 	/** @type {Set<string>} */
 	const usedIds = new Set();
 	if (compilation.usedModuleIds) {
@@ -248,15 +251,23 @@ const getUsedModuleIds = compilation => {
 	}
 
 	for (const module of compilation.modules) {
+		if (!module.needId) continue;
 		const moduleId = chunkGraph.getModuleId(module);
 		if (moduleId !== null) {
 			usedIds.add(moduleId + "");
+		} else {
+			if (
+				(!filter || filter(module)) &&
+				chunkGraph.getNumberOfModuleChunks(module) !== 0
+			) {
+				modules.push(module);
+			}
 		}
 	}
 
-	return usedIds;
+	return [usedIds, modules];
 };
-exports.getUsedModuleIds = getUsedModuleIds;
+exports.getUsedModuleIdsAndModules = getUsedModuleIdsAndModules;
 
 /**
  * @param {Compilation} compilation the compilation
@@ -359,6 +370,7 @@ exports.assignNames = assignNames;
  * @param {number[]} ranges usable ranges for ids
  * @param {number} expandFactor factor to create more ranges
  * @param {number} extraSpace extra space to allocate, i. e. when some ids are already used
+ * @param {number} salt salting number to initialize hashing
  * @returns {void}
  */
 const assignDeterministicIds = (
@@ -368,7 +380,8 @@ const assignDeterministicIds = (
 	assignId,
 	ranges = [10],
 	expandFactor = 10,
-	extraSpace = 0
+	extraSpace = 0,
+	salt = 0
 ) => {
 	items.sort(comparator);
 
@@ -384,15 +397,17 @@ const assignDeterministicIds = (
 		i++;
 		if (i < ranges.length) {
 			range = Math.min(ranges[i], Number.MAX_SAFE_INTEGER);
-		} else {
+		} else if (expandFactor) {
 			range = Math.min(range * expandFactor, Number.MAX_SAFE_INTEGER);
+		} else {
+			break;
 		}
 	}
 
 	for (const item of items) {
 		const ident = getName(item);
 		let id;
-		let i = 0;
+		let i = salt;
 		do {
 			id = numberHash(ident + i++, range);
 		} while (!assignId(item, id));
@@ -401,15 +416,14 @@ const assignDeterministicIds = (
 exports.assignDeterministicIds = assignDeterministicIds;
 
 /**
+ * @param {Set<string>} usedIds used ids
  * @param {Iterable<Module>} modules the modules
  * @param {Compilation} compilation the compilation
  * @returns {void}
  */
-const assignAscendingModuleIds = (modules, compilation) => {
+const assignAscendingModuleIds = (usedIds, modules, compilation) => {
 	const chunkGraph = compilation.chunkGraph;
 
-	const usedIds = getUsedModuleIds(compilation);
-
 	let nextId = 0;
 	let assignId;
 	if (usedIds.size > 0) {