@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/ids/HashedModuleIdsPlugin.js

@@ -10,6 +10,7 @@ const {
 	compareModulesByPreOrderIndexOrIdentifier
 } = require("../util/comparators");
 const createHash = require("../util/createHash");
+const { fileUrlToPath } = require("../util/identifier");
 const {
 	getFullModuleName,
 	getUsedModuleIdsAndModules
@@ -58,7 +59,7 @@ class HashedModuleIdsPlugin {
 			compilation.hooks.moduleIds.tap(PLUGIN_NAME, () => {
 				const chunkGraph = compilation.chunkGraph;
 				const context = this.options.context
-					? this.options.context
+					? fileUrlToPath(this.options.context)
 					: compiler.context;
 
 				const [usedIds, modules] = getUsedModuleIdsAndModules(compilation);

package/lib/index.js

@@ -38,7 +38,7 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./asset/AssetModule").AssetModuleBuildInfo} AssetModuleBuildInfo */
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./Compiler").AssetEmittedInfo} AssetEmittedInfo */
-/** @typedef {import("./ContextModule").ContextModuleBuildInfo} ContextModuleBuildInfo */
+/** @typedef {import("./context/ContextModule").ContextModuleBuildInfo} ContextModuleBuildInfo */
 /** @typedef {import("./css/CssModule").CssModuleBuildInfo} CssModuleBuildInfo */
 /** @typedef {import("./css/CssModule").CssModuleBuildMeta} CssModuleBuildMeta */
 /** @typedef {import("./ExternalModule").ExternalModuleBuildInfo} ExternalModuleBuildInfo */
@@ -237,10 +237,13 @@ module.exports = mergeExports(fn, {
 		return require("./ConcatenationScope");
 	},
 	get ContextExclusionPlugin() {
-		return require("./ContextExclusionPlugin");
+		return require("./context/ContextExclusionPlugin");
 	},
 	get ContextReplacementPlugin() {
-		return require("./ContextReplacementPlugin");
+		return require("./context/ContextReplacementPlugin");
+	},
+	get CopyPlugin() {
+		return require("./CopyPlugin");
 	},
 	get DefinePlugin() {
 		return require("./DefinePlugin");
@@ -740,3 +743,46 @@ module.exports = mergeExports(fn, {
 		}
 	}
 });
+
+/**
+ * The loader-authoring types, re-exported here because this file is what
+ * `generate-types.js` reads webpack's public type surface from
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").LoaderModule<OptionsType, ContextAdditions>} LoaderModule
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").RawLoaderDefinition<OptionsType, ContextAdditions>} RawLoaderDefinition
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").LoaderDefinition<OptionsType, ContextAdditions>} LoaderDefinition
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").LoaderDefinitionFunction<OptionsType, ContextAdditions>} LoaderDefinitionFunction
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").PitchLoaderDefinitionFunction<OptionsType, ContextAdditions>} PitchLoaderDefinitionFunction
+ */
+
+/**
+ * @template [OptionsType={}]
+ * @template [ContextAdditions={}]
+ * @typedef {import("./loaders/LoaderRunner").RawLoaderDefinitionFunction<OptionsType, ContextAdditions>} RawLoaderDefinitionFunction
+ */
+
+/**
+ * @template OptionsType
+ * @typedef {import("./NormalModule").LoaderContext<OptionsType>} LoaderContext
+ */

package/lib/javascript/ChunkFormatHelpers.js

@@ -55,10 +55,11 @@ function createChunkHashHandler(name) {
 		hash.update(name);
 		hash.update("1");
 		if (runtimeChunk && runtimeChunk.hash) {
-			// https://github.com/webpack/webpack/issues/19439
-			// Any change to runtimeChunk should trigger a hash update,
-			// we shouldn't depend on or inspect its internal implementation.
+			// WHY: any change to the runtime chunk must move this hash, and its
+			// internal implementation is not ours to depend on or inspect — the import
+			// names its hashed filename:
 			// import __webpack_require__ from "./runtime-main.e9400aee33633a3973bd.js";
+			// https://github.com/webpack/webpack/issues/19439
 			hash.update(runtimeChunk.hash);
 		}
 		updateHashForEntryStartup(hash, chunkGraph, entries, chunk);

package/lib/javascript/JavascriptGenerator.js

@@ -256,6 +256,7 @@ class JavascriptGenerator extends Generator {
 				/** @type {NonNullable<GenerateContext["codeGenerationResults"]>} */
 				(generateContext.codeGenerationResults),
 			initFragments,
+			getData: generateContext.getData,
 			get chunkInitFragments() {
 				if (!chunkInitFragments) {
 					const data =
@@ -332,7 +333,13 @@ class JavascriptGenerator extends Generator {
 	 * @returns {Source | null} generated code
 	 */
 	generateError(error, module, generateContext) {
-		return new RawSource(Generator.throwBuildErrorCode(error));
+		return new RawSource(
+			Generator.throwBuildErrorCode(
+				error,
+				undefined,
+				generateContext.runtimeTemplate.requestShortener
+			)
+		);
 	}
 }
 

package/lib/javascript/JavascriptModule.js

@@ -19,6 +19,7 @@ const makeSerializable = require("../util/makeSerializable");
  * Defines the build info properties specific to javascript modules.
  * @typedef {object} KnownJavascriptModuleBuildInfo
  * @property {string=} moduleConcatenationBailout using in CommonJs
+ * @property {string=} moduleConcatenationRootBailout what rules the module out as a concatenation root, while it may still be an inner module
  * @property {boolean=} needCreateRequire using in APIPlugin
  * @property {boolean=} usingPublicPathOverride module reassigns `__webpack_public_path__` at runtime, using in APIPlugin
  * @property {Set<string>=} pureFunctions names of locally declared functions known to be free of side effects

package/lib/javascript/JavascriptModulesPlugin.js

@@ -57,27 +57,12 @@ const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptModule = require("./JavascriptModule");
 const JavascriptParser = require("./JavascriptParser");
 const analyzeScope = require("./ScopeAnalyzer");
+const { renderAwaitedEntries } = require("./StartupHelpers");
+const { releaseParserCaches } = require("./syntax");
 
 /**
  * @import {
- * 	Program,
- * 	Node,
- * 	Identifier,
- * 	CatchClause,
- * 	ClassDeclaration,
- * 	ClassExpression,
- * 	FunctionDeclaration,
- * 	FunctionExpression,
- * 	ArrowFunctionExpression,
- * 	VariableDeclarator,
- * 	VariableDeclaration,
- * 	ImportDeclaration,
- * 	ImportSpecifier,
- * 	ImportDefaultSpecifier,
- * 	ImportNamespaceSpecifier,
- * 	AssignmentExpression,
- * 	ForInStatement,
- * 	ForOfStatement
+ * 	Program
  * } from "estree"
  */
 /** @import { Source } from "webpack-sources" */
@@ -93,7 +78,6 @@ const analyzeScope = require("./ScopeAnalyzer");
 /** @import DependencyTemplates from "../DependencyTemplates" */
 /** @import Entrypoint from "../Entrypoint" */
 /** @import Module, { BuildInfo, CodeGenerationResultData } from "../Module" */
-/** @import { RuntimeSpec } from "../util/runtime" */
 /** @import ModuleGraph from "../ModuleGraph" */
 /** @import RuntimeTemplate from "../RuntimeTemplate" */
 /** @import WebpackError from "../errors/WebpackError" */
@@ -347,18 +331,6 @@ const createCompilationHooks = () => ({
 	 * @since 5.22.0
 	 */
 	inlineInRuntimeBailout: new SyncBailHook(["module", "renderContext"]),
-	/**
-	 * Offers a module's rendered export-definition call to a consumer that can place
-	 * it better — a library whose entry exports the same bindings natively takes it
-	 * over and emits it only where the module is wrapped. Return true to take it.
-	 * @type {SyncBailHook<[Module, RuntimeSpec, string, boolean], boolean | void>}
-	 */
-	onDemandExportsGeneration: new SyncBailHook([
-		"module",
-		"runtime",
-		"source",
-		"placeAtEnd"
-	]),
 	/**
 	 * @type {SyncBailHook<[Module, RenderContext], string | void>}
 	 * @since 5.22.0
@@ -470,6 +442,10 @@ class JavascriptModulesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
+		// the parser's shared string caches only pay off while modules parse —
+		// drop them when the build ends so an idle process retains no parser state
+		compiler.hooks.done.tap(PLUGIN_NAME, releaseParserCaches);
+		compiler.hooks.failed.tap(PLUGIN_NAME, releaseParserCaches);
 		compiler.hooks.compilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
@@ -1608,17 +1584,14 @@ class JavascriptModulesPlugin {
 		}
 
 		if (runtimeRequirements.has(RuntimeGlobals.makeDeferredNamespaceObject)) {
-			// in order to optimize of DeferredNamespaceObject, we remove all proxy handlers after the module initialize
-			// (see MakeDeferredNamespaceObjectRuntimeModule)
-			// This requires all deferred imports to a module can get the module export object before the module
-			// is evaluated.
+			// The deferred namespace drops its proxy handlers once the module has
+			// initialized, which needs every deferred import of it to reach the exports
+			// object before evaluation.
 			buf.push("// The deferred module cache");
 			buf.push(`${bootstrapCst} __webpack_module_deferred_exports__ = {};`);
-			// Per the TC39 import-defer spec, every defer-import call site for
-			// the same module must yield the same Deferred Module Namespace
-			// Exotic Object (and a distinct one from any eager namespace).
-			// Cache the deferred namespace proxy here so calls from different
-			// files share identity.
+			// Every defer-import site for one module must yield the same Deferred
+			// Module Namespace, distinct from any eager one, so the proxy is cached
+			// here for call sites in different files to share.
 			buf.push("// The deferred namespace cache");
 			buf.push(
 				`${bootstrapCst} __webpack_module_deferred_namespace_cache__ = {};`
@@ -1680,8 +1653,27 @@ class JavascriptModulesPlugin {
 						continue;
 					}
 				}
-				// An async entry is not awaited here: that needs top-level `await`,
-				// gated on an option held back from the patch release (revert #21881).
+				const entryOptions = chunk.getEntryOptions();
+				const library =
+					entryOptions && entryOptions.library !== undefined
+						? entryOptions.library
+						: runtimeTemplate.outputOptions.library;
+				// A module library awaits the entry itself, in `ModuleLibraryPlugin`.
+				const awaitedByLibrary =
+					library !== undefined && library.type === "module";
+				// `await` is legal only at an ESM chunk's top level, never in the
+				// startup function below, and only where the target parses it.
+				const canAwaitEntry =
+					runtimeTemplate.isModule() &&
+					runtimeTemplate.supportsTopLevelAwait() &&
+					!awaitedByLibrary &&
+					!runtimeRequirements.has(RuntimeGlobals.startup) &&
+					!(
+						runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
+						runtimeRequirements.has(RuntimeGlobals.startupOnlyAfter)
+					);
+				/** @type {string[]} */
+				const awaitedEntries = [];
 				let i = jsEntries.length;
 				for (const [entryModule, entrypoint] of jsEntries) {
 					const chunks =
@@ -1789,30 +1781,45 @@ class JavascriptModulesPlugin {
 						result.allowInlineStartup = false;
 					}
 
-					// `__webpack_exports__` may be reassigned later — by the
-					// `onChunksLoaded` wrapper below, by an inlined entry
-					// module that uses top-level `await` (the emitted
-					// bridge reassigns `__webpack_exports__` to the awaited
-					// value), or by other downstream codegen. Always declare
-					// with `let` (or `var` if `let` is unsupported) so
-					// reassignment is allowed.
+					// `__webpack_exports__` may be reassigned later, by the
+					// `onChunksLoaded` wrapper, a top-level `await` bridge or other
+					// codegen, so it is never declared as a constant.
 					const exportsDecl = runtimeTemplate.renderLet();
 					if (chunks.length > 0) {
+						const awaitEntry =
+							canAwaitEntry && moduleGraph.isAsync(entryModule);
+						const target =
+							i === 0
+								? RuntimeGlobals.exports
+								: `${RuntimeGlobals.exports}_${i}`;
+						// The wrapper hands back nothing until the flush below runs the
+						// entry, so an awaited one is caught by the entry call itself.
+						if (awaitEntry && i !== 0) buf2.push(`${exportsDecl} ${target};`);
+						const entryCall = `${RuntimeGlobals.require}(${moduleIdExpr})`;
 						buf2.push(
 							`${i === 0 ? `${exportsDecl} ${RuntimeGlobals.exports} = ` : ""}${
 								RuntimeGlobals.onChunksLoaded
 							}(undefined, ${JSON.stringify(
 								chunks.map((c) => c.id)
 							)}, ${runtimeTemplate.returningFunction(
-								`${RuntimeGlobals.require}(${moduleIdExpr})`
+								awaitEntry ? `(${target} = ${entryCall})` : entryCall
 							)})`
 						);
+						if (awaitEntry) awaitedEntries.push(target);
 					} else if (useRequire) {
+						// An async entry nobody awaits settles after the bundle did,
+						// which orphans its rejection.
+						const awaitEntry =
+							canAwaitEntry && moduleGraph.isAsync(entryModule);
+						const target =
+							i === 0
+								? RuntimeGlobals.exports
+								: `${RuntimeGlobals.exports}_${i}`;
+						const needsDecl = i === 0 || awaitEntry;
 						buf2.push(
-							`${i === 0 ? `${exportsDecl} ${RuntimeGlobals.exports} = ` : ""}${
-								RuntimeGlobals.require
-							}(${moduleIdExpr});`
+							`${needsDecl ? `${exportsDecl} ${target} = ` : ""}${RuntimeGlobals.require}(${moduleIdExpr});`
 						);
+						if (awaitEntry) awaitedEntries.push(target);
 					} else {
 						if (i === 0) {
 							buf2.push(`${exportsDecl} ${RuntimeGlobals.exports} = {};`);
@@ -1855,6 +1862,7 @@ class JavascriptModulesPlugin {
 						`${RuntimeGlobals.exports} = ${RuntimeGlobals.onChunksLoaded}(${RuntimeGlobals.exports});`
 					);
 				}
+				buf2.push(...renderAwaitedEntries(awaitedEntries));
 				if (
 					runtimeRequirements.has(RuntimeGlobals.startup) ||
 					(runtimeRequirements.has(RuntimeGlobals.startupOnlyBefore) &&
@@ -1984,11 +1992,9 @@ class JavascriptModulesPlugin {
 		const needModuleDefer = runtimeRequirements.has(
 			RuntimeGlobals.makeDeferredNamespaceObject
 		);
-		// Both deferred-namespace runtimes re-invoke `__webpack_require__` on
-		// access, so a module's evaluation error must be retained and re-thrown
-		// (a Cyclic Module Record's [[EvaluationError]]); the optimized variant
-		// does not use `__webpack_module_deferred_exports__`, so it is tracked
-		// separately from `needModuleDefer`.
+		// Both deferred-namespace runtimes re-invoke `__webpack_require__` on access,
+		// so an evaluation error must be retained and re-thrown. The optimized one
+		// skips the deferred exports object, hence the separate flag.
 		const needModuleDeferAny =
 			needModuleDefer ||
 			runtimeRequirements.has(
@@ -2116,10 +2122,9 @@ class JavascriptModulesPlugin {
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict);
 		const isMultipleEntries = inlinedModules.size > 1;
 		const singleEntryWithModules = inlinedModules.size === 1 && hasChunkModules;
-		// This step is before the IIFE reason calculation; it only runs for the
-		// cases whose IIFE reason it can remove: multiple inlined entry modules, or a
-		// single inlined entry alongside other chunk modules. The remaining reason
-		// ('it uses a non-standard name for the exports') is not handled here.
+		// Runs before the IIFE reason is calculated, and only for the cases whose
+		// reason it can remove: several inlined entries, or one beside other chunk
+		// modules. A non-standard exports name is not handled here.
 		if (innerStrict || (!isMultipleEntries && !singleEntryWithModules)) {
 			return false;
 		}
@@ -2178,11 +2183,9 @@ class JavascriptModulesPlugin {
 			}
 		}
 
-		// Fast path: codegen reports each inlined entry's rendered top-level
-		// declarations and free names (post-concatenation), so when no declaration
-		// collides with a free name of any other module, another entry's
-		// declarations, or a reserved name, no renaming is needed and the entries
-		// don't have to be parsed at all.
+		// Codegen reports each inlined entry's rendered top-level declarations and
+		// free names, so where nothing collides there is no renaming to do and the
+		// entries need not be parsed at all.
 		fastPath: {
 			const { codeGenerationResults, chunk } = renderContext;
 			/** @type {Set<string>} */
@@ -2267,11 +2270,9 @@ class JavascriptModulesPlugin {
 			}
 		}
 
-		// Multiple inlined entry modules share the chunk's startup scope. Rename any
-		// top-level declaration that would collide with another inlined module's
-		// declaration, with any inlined or non-inlined module's free (global)
-		// reference, or with a reserved name, so the modules can be emitted without a
-		// per-entry IIFE.
+		// Several inlined entries share the chunk's startup scope, so any top-level
+		// declaration colliding with another's declaration, any module's free
+		// reference or a reserved name is renamed, sparing them a per-entry IIFE.
 		if (isMultipleEntries) {
 			/** @type {Set<string>} */
 			const allUsedNames = new Set(nonInlinedModuleThroughIdentifiers);