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

package/lib/javascript/JavascriptModule.js

@@ -7,17 +7,23 @@
 const NormalModule = require("../NormalModule");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../NormalModule").NormalModuleBuildInfo} NormalModuleBuildInfo */
-/** @typedef {import("../NormalModule").NormalModuleCreateData} NormalModuleCreateData */
+/** @import { BuildMeta } from "../Module" */
+/**
+ * @import {
+ * 	NormalModuleBuildInfo,
+ * 	NormalModuleCreateData
+ * } from "../NormalModule"
+ */
 
 /**
  * Defines the build info properties specific to javascript modules.
  * @typedef {object} KnownJavascriptModuleBuildInfo
  * @property {string=} moduleConcatenationBailout using in CommonJs
  * @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
  * @property {boolean=} inlineExports whether this module was parsed with `optimization.inlineExports` enabled (gates inlining of its exports)
+ * @property {boolean=} usesTopLevelUsingDeclaration module scope holds a `using`/`await using` declaration, so its resources must be disposed when the module finished evaluating
  */
 
 /** @typedef {NormalModuleBuildInfo & KnownJavascriptModuleBuildInfo} JavascriptModuleBuildInfo */

package/lib/javascript/JavascriptModulesPlugin.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const vm = require("vm");
-const eslintScope = require("eslint-scope");
 const { SyncBailHook, SyncHook, SyncWaterfallHook } = require("tapable");
 const {
 	CachedSource,
@@ -16,7 +15,13 @@ const {
 	RawSource,
 	ReplaceSource
 } = require("webpack-sources");
-/** @typedef {import("../Compilation")} Compilation */
+/**
+ * @import Compilation, {
+ * 	ChunkHashContext,
+ * 	ExecuteModuleObject,
+ * 	WebpackRequire
+ * } from "../Compilation"
+ */
 const HotUpdateChunk = require("../HotUpdateChunk");
 const InitFragment = require("../InitFragment");
 const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
@@ -34,6 +39,7 @@ const { last, someInIterable } = require("../util/IterableHelpers");
 const StringXor = require("../util/StringXor");
 const { compareModulesByFullName } = require("../util/comparators");
 const {
+	CHUNK_RUNTIME_DECLARATIONS,
 	RESERVED_NAMES,
 	addScopeSymbols,
 	findNewName,
@@ -44,109 +50,60 @@ const {
 const createHash = require("../util/createHash");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const { digestNonNumericOnlyWithFull } = require("../util/nonNumericOnlyHash");
-const removeBOM = require("../util/removeBOM");
+const { removeBOMFromResult } = require("../util/removeBOM");
 const { intersectRuntime } = require("../util/runtime");
 const { getAllChunks } = require("./ChunkHelpers");
 const JavascriptGenerator = require("./JavascriptGenerator");
 const JavascriptModule = require("./JavascriptModule");
 const JavascriptParser = require("./JavascriptParser");
-
-/** @typedef {import("estree").Program} Program */
-/** @typedef {import("estree").Node} Node */
-/** @typedef {import("estree").Identifier} Identifier */
-/** @typedef {import("estree").CatchClause} CatchClause */
-/** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
-/** @typedef {import("estree").ClassExpression} ClassExpression */
-/** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
-/** @typedef {import("estree").FunctionExpression} FunctionExpression */
-/** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
-/** @typedef {import("estree").VariableDeclarator} VariableDeclarator */
-/** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
-/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */
-/** @typedef {import("estree").ImportDefaultSpecifier} ImportDefaultSpecifier */
-/** @typedef {import("estree").ImportNamespaceSpecifier} ImportNamespaceSpecifier */
-/** @typedef {import("estree").AssignmentExpression} AssignmentExpression */
-/** @typedef {import("estree").ForInStatement} ForInStatement */
-/** @typedef {import("estree").ForOfStatement} ForOfStatement */
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("../config/defaults").OutputNormalizedWithDefaults} OutputOptions */
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../ChunkGraph").EntryModuleWithChunkGroup} EntryModuleWithChunkGroup */
-/** @typedef {import("../CodeGenerationResults")} CodeGenerationResults */
-/** @typedef {import("../Compilation").ChunkHashContext} ChunkHashContext */
-/** @typedef {import("../Compilation").ExecuteModuleObject} ExecuteModuleObject */
-/** @typedef {import("../Compilation").WebpackRequire} WebpackRequire */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../DependencyTemplates")} DependencyTemplates */
-/** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../Module")} Module */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").CodeGenerationResultData} CodeGenerationResultData */
-/** @typedef {import("../ModuleGraph")} ModuleGraph */
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {import("../Chunk").ChunkFilenameTemplate} ChunkFilenameTemplate */
-/** @typedef {import("../errors/WebpackError")} WebpackError */
-/** @typedef {import("../javascript/JavascriptParser").Range} Range */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/concatenate").ScopeSet} ScopeSet */
-/** @typedef {import("../util/concatenate").UsedNamesInScopeInfo} UsedNamesInScopeInfo */
-
-// TODO remove these types when we will update `eslint-scope` to the latest version and import them from `eslint-scope`
-/**
- * @typedef {object} Scope
- * @property {"block" | "catch" | "class" | "class-field-initializer" | "class-static-block" | "for" | "function" | "function-expression-name" | "global" | "module" | "switch" | "with" | "TDZ"} type
- * @property {boolean} isStrict
- * @property {Scope | null} upper
- * @property {Scope[]} childScopes
- * @property {Scope} variableScope
- * @property {Node} block
- * @property {Variable[]} variables
- * @property {Map<string, Variable>} set
- * @property {Reference[]} references
- * @property {Reference[]} through
- * @property {boolean} functionExpressionScope
- * @property {{ variables: Variable[], set: Map<string, Variable> }=} implicit
- */
-
-/**
- * @typedef {
- * | { type: "CatchClause", node: CatchClause, parent: null }
- * | { type: "ClassName", node: ClassDeclaration | ClassExpression, parent: null }
- * | { type: "FunctionName", node: FunctionDeclaration | FunctionExpression, parent: null }
- * | { type: "ImplicitGlobalVariable", node: AssignmentExpression | ForInStatement | ForOfStatement, parent: null }
- * | { type: "ImportBinding", node: ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier, parent: ImportDeclaration }
- * | { type: "Parameter", node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression, parent: null }
- * | { type: "TDZ", node: any, parent: null }
- * | { type: "Variable", node: VariableDeclarator, parent: VariableDeclaration }
- * } DefinitionType
- */
-
-/** @typedef {DefinitionType & { name: Identifier }} Definition */
+const analyzeScope = require("./ScopeAnalyzer");
 
 /**
- * @typedef {object} Variable
- * @property {string} name
- * @property {Scope} scope
- * @property {Identifier[]} identifiers
- * @property {Reference[]} references
- * @property {Definition[]} defs
+ * @import {
+ * 	Program,
+ * 	Node,
+ * 	Identifier,
+ * 	CatchClause,
+ * 	ClassDeclaration,
+ * 	ClassExpression,
+ * 	FunctionDeclaration,
+ * 	FunctionExpression,
+ * 	ArrowFunctionExpression,
+ * 	VariableDeclarator,
+ * 	VariableDeclaration,
+ * 	ImportDeclaration,
+ * 	ImportSpecifier,
+ * 	ImportDefaultSpecifier,
+ * 	ImportNamespaceSpecifier,
+ * 	AssignmentExpression,
+ * 	ForInStatement,
+ * 	ForOfStatement
+ * } from "estree"
  */
-
+/** @import { Source } from "webpack-sources" */
 /**
- * @typedef {object} Reference
- * @property {Identifier} identifier
- * @property {Scope} from
- * @property {Variable | null} resolved
- * @property {Node | null} writeExpr
- * @property {boolean} init
- * @property {() => boolean} isWrite
- * @property {() => boolean} isRead
- * @property {() => boolean} isWriteOnly
- * @property {() => boolean} isReadOnly
- * @property {() => boolean} isReadWrite
+ * @import {
+ * 	OutputNormalizedWithDefaults as OutputOptions
+ * } from "../config/defaults"
  */
+/** @import Chunk, { ChunkFilenameTemplate } from "../Chunk" */
+/** @import ChunkGraph, { EntryModuleWithChunkGroup } from "../ChunkGraph" */
+/** @import CodeGenerationResults from "../CodeGenerationResults" */
+/** @import Compiler from "../Compiler" */
+/** @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" */
+/** @import { Range } from "../javascript/JavascriptParser" */
+/** @import Hash from "../util/Hash" */
+/** @import { ScopeSet, UsedNamesInScopeInfo } from "../util/concatenate" */
+
+/** @typedef {import("./ScopeAnalyzer").Scope} Scope */
+/** @typedef {import("./ScopeAnalyzer").Variable} Variable */
+/** @typedef {import("./ScopeAnalyzer").Reference} Reference */
 
 /** @type {WeakMap<ChunkGraph, WeakMap<Chunk, boolean>>} */
 const chunkHasJsCache = new WeakMap();
@@ -390,6 +347,18 @@ 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
@@ -559,15 +528,8 @@ class JavascriptModulesPlugin {
 
 					NormalModule.getCompilationHooks(compilation).processResult.tap(
 						PLUGIN_NAME,
-						(result, module) => {
-							if (module.type === type) {
-								const [source, ...rest] = result;
-
-								return [removeBOM(source), ...rest];
-							}
-
-							return result;
-						}
+						(result, module) =>
+							module.type === type ? removeBOMFromResult(result) : result
 					);
 				}
 
@@ -1228,7 +1190,17 @@ class JavascriptModulesPlugin {
 			!allStrict &&
 			allModules.every((m) => /** @type {BuildInfo} */ (m.buildInfo).strict)
 		) {
-			const strictBailout = hooks.strictRuntimeBailout.call(renderContext);
+			// a non-arrow bootstrap IIFE is called without a receiver, so in strict
+			// mode the `this` that `output.globalObject` reads would be undefined
+			const globalObjectNeedsThis =
+				iife &&
+				!runtimeTemplate.supportsArrowFunction() &&
+				runtimeTemplate.globalObjectUsesThis();
+			const strictBailout =
+				hooks.strictRuntimeBailout.call(renderContext) ||
+				(globalObjectNeedsThis
+					? "'output.globalObject' reads 'this'"
+					: undefined);
 			if (strictBailout) {
 				source.add(
 					`${prefix}// runtime can't be in strict mode because ${strictBailout}.\n`
@@ -1708,6 +1680,8 @@ 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).
 				let i = jsEntries.length;
 				for (const [entryModule, entrypoint] of jsEntries) {
 					const chunks =
@@ -1759,6 +1733,23 @@ class JavascriptModulesPlugin {
 						);
 						result.allowInlineStartup = false;
 					}
+					if (result.allowInlineStartup) {
+						// the bail-out above already established that one of the two
+						// sources carries them
+						const topLevelDeclarations =
+							(data && data.get("topLevelDeclarations")) ||
+							/** @type {BuildInfo} */ (entryModule.buildInfo)
+								.topLevelDeclarations;
+						for (const name of CHUNK_RUNTIME_DECLARATIONS) {
+							if (/** @type {Set<string>} */ (topLevelDeclarations).has(name)) {
+								buf2.push(
+									`// This entry module declares '${name}' on top-level, which the runtime also declares, so it can't be inlined`
+								);
+								result.allowInlineStartup = false;
+								break;
+							}
+						}
+					}
 					if (result.allowInlineStartup) {
 						const bailout = hooks.inlineInRuntimeBailout.call(
 							entryModule,
@@ -2180,15 +2171,9 @@ class JavascriptModulesPlugin {
 				JavascriptParser._getModuleParseFunction(compilation, m)
 			);
 
-			const scopeManager = eslintScope.analyze(ast, {
-				ecmaVersion: 6,
-				sourceType: "module",
-				optimistic: true,
-				ignoreEval: true
-			});
+			const analysis = analyzeScope(ast);
 
-			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
-			for (const ref of globalScope.through) {
+			for (const ref of analysis.unresolvedReferences) {
 				nonInlinedModuleThroughIdentifiers.add(ref.identifier.name);
 			}
 		}
@@ -2257,21 +2242,15 @@ class JavascriptModulesPlugin {
 				JavascriptParser._getModuleParseFunction(compilation, m)
 			);
 
-			const scopeManager = eslintScope.analyze(ast, {
-				ecmaVersion: 6,
-				sourceType: "module",
-				optimistic: true,
-				ignoreEval: true
-			});
+			const analysis = analyzeScope(ast);
 
-			const globalScope = /** @type {Scope} */ (scopeManager.acquire(ast));
-			const moduleScope = globalScope.childScopes[0];
+			const moduleScope = analysis.moduleScope;
 			inlinedModulesToInfo.set(m, {
 				source: moduleSource,
 				ast,
 				module: m,
 				variables: new Set(moduleScope.variables),
-				through: new Set(moduleScope.through),
+				through: new Set(analysis.unresolvedReferences),
 				usedInNonInlined: new Set(),
 				moduleScope
 			});
@@ -2357,5 +2336,6 @@ JavascriptModulesPlugin.getCompilationHooks = createHooksRegistry(
 	createCompilationHooks
 );
 
+JavascriptModulesPlugin.chunkHasJs = chunkHasJs;
+
 module.exports = JavascriptModulesPlugin;
-module.exports.chunkHasJs = chunkHasJs;