webpack 5.101.1 → 5.101.2

package/lib/ChunkGraph.js

@@ -1242,7 +1242,7 @@ class ChunkGraph {
 	 * @param {Chunk} chunk the chunk
 	 * @returns {Iterable<Chunk>} iterable of chunks and include chunks from children entrypoints
 	 */
-	getChunkEntryDependOnChunksIterable(chunk) {
+	getRuntimeChunkDependentChunksIterable(chunk) {
 		/** @type {Set<Chunk>} */
 		const set = new Set();
 
@@ -1259,7 +1259,7 @@ class ChunkGraph {
 
 						let hasChildrenEntrypoint = false;
 						for (const child of current.childrenIterable) {
-							if (child.isInitial()) {
+							if (child instanceof Entrypoint && child.dependOn(current)) {
 								hasChildrenEntrypoint = true;
 								queue.push(/** @type {Entrypoint} */ (child));
 							}
@@ -1277,6 +1277,18 @@ class ChunkGraph {
 				}
 			}
 		}
+
+		for (const entrypoint of entrypoints) {
+			const entrypointChunk = entrypoint.getEntrypointChunk();
+			const cgc = this._getChunkGraphChunk(entrypointChunk);
+			for (const chunkGroup of cgc.entryModules.values()) {
+				for (const c of chunkGroup.chunks) {
+					if (c !== chunk && c !== entrypointChunk && !c.hasRuntime()) {
+						set.add(c);
+					}
+				}
+			}
+		}
 		return set;
 	}
 

package/lib/Compilation.js

@@ -32,7 +32,8 @@ const ErrorHelpers = require("./ErrorHelpers");
 const FileSystemInfo = require("./FileSystemInfo");
 const {
 	connectChunkGroupAndChunk,
-	connectChunkGroupParentAndChild
+	connectChunkGroupParentAndChild,
+	connectEntrypointAndDependOn
 } = require("./GraphHelpers");
 const {
 	makeWebpackError,
@@ -3207,7 +3208,6 @@ Remove the 'runtime' option from the entrypoint.`);
 				const referencedChunks = entry
 					.getEntrypointChunk()
 					.getAllReferencedChunks();
-				const dependOnEntries = [];
 				for (const dep of dependOn) {
 					const dependency = this.entrypoints.get(dep);
 					if (!dependency) {
@@ -3225,9 +3225,7 @@ Remove the 'runtime' option from the entrypoint.`);
 						entry.setRuntimeChunk(entryChunk);
 						continue outer;
 					}
-					dependOnEntries.push(dependency);
-				}
-				for (const dependency of dependOnEntries) {
+					connectEntrypointAndDependOn(entry, dependency);
 					connectChunkGroupParentAndChild(dependency, entry);
 				}
 			} else if (runtime) {
@@ -3278,26 +3276,6 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 		this.hooks.afterOptimizeChunks.call(this.chunks, this.chunkGroups);
 
-		for (const [
-			name,
-			{
-				options: { dependOn }
-			}
-		] of this.entries) {
-			if (dependOn) {
-				const entry = /** @type {Entrypoint} */ (this.entrypoints.get(name));
-				for (const dep of dependOn) {
-					const depEntry = /** @type {Entrypoint} */ (
-						this.entrypoints.get(dep)
-					);
-					const runtimeChunk = depEntry.getRuntimeChunk();
-					if (runtimeChunk) {
-						runtimeChunk.addGroup(entry);
-					}
-				}
-			}
-		}
-
 		this.hooks.optimizeTree.callAsync(this.chunks, this.modules, (err) => {
 			if (err) {
 				return finalCallback(

package/lib/Entrypoint.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const ChunkGroup = require("./ChunkGroup");
+const SortableSet = require("./util/SortableSet");
 
 /** @typedef {import("../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescription */
 /** @typedef {import("./Chunk")} Chunk */
@@ -38,6 +39,8 @@ class Entrypoint extends ChunkGroup {
 		this._entrypointChunk = undefined;
 		/** @type {boolean} */
 		this._initial = initial;
+		/** @type {SortableSet<Entrypoint>} */
+		this._dependOn = new SortableSet();
 	}
 
 	/**
@@ -96,6 +99,22 @@ class Entrypoint extends ChunkGroup {
 		if (this._entrypointChunk === oldChunk) this._entrypointChunk = newChunk;
 		return super.replaceChunk(oldChunk, newChunk);
 	}
+
+	/**
+	 * @param {Entrypoint} entrypoint the entrypoint
+	 * @returns {void}
+	 */
+	addDependOn(entrypoint) {
+		this._dependOn.add(entrypoint);
+	}
+
+	/**
+	 * @param {Entrypoint} entrypoint the entrypoint
+	 * @returns {boolean} true if the entrypoint is in the dependOn set
+	 */
+	dependOn(entrypoint) {
+		return this._dependOn.has(entrypoint);
+	}
 }
 
 module.exports = Entrypoint;

package/lib/GraphHelpers.js

@@ -10,6 +10,7 @@
 /** @typedef {import("./ChunkGroup")} ChunkGroup */
 /** @typedef {import("./DependenciesBlock")} DependenciesBlock */
 /** @typedef {import("./Module")} Module */
+/** @typedef {import(".").Entrypoint} Entrypoint */
 
 /**
  * @param {ChunkGroup} chunkGroup the ChunkGroup to connect
@@ -33,6 +34,16 @@ const connectChunkGroupParentAndChild = (parent, child) => {
 	}
 };
 
+/**
+ * @param {Entrypoint} entrypoint the entrypoint
+ * @param {Entrypoint} dependOnEntrypoint the dependOnEntrypoint
+ * @returns {void}
+ */
+const connectEntrypointAndDependOn = (entrypoint, dependOnEntrypoint) => {
+	entrypoint.addDependOn(dependOnEntrypoint);
+};
+
 module.exports.connectChunkGroupAndChunk = connectChunkGroupAndChunk;
 module.exports.connectChunkGroupParentAndChild =
 	connectChunkGroupParentAndChild;
+module.exports.connectEntrypointAndDependOn = connectEntrypointAndDependOn;

package/lib/JavascriptMetaInfoPlugin.js

@@ -54,8 +54,7 @@ class JavascriptMetaInfoPlugin {
 							topLevelDeclarations = buildInfo.topLevelDeclarations = new Set();
 						}
 						for (const name of parser.scope.definitions.asSet()) {
-							const freeInfo = parser.getFreeInfoFromVariable(name);
-							if (freeInfo === undefined) {
+							if (parser.isVariableDefined(name)) {
 								topLevelDeclarations.add(name);
 							}
 						}

package/lib/javascript/JavascriptParser.js

@@ -258,17 +258,42 @@ const getImportAttributes = (node) => {
 	return result;
 };
 
+/** @typedef {typeof VariableInfoFlags.Evaluated | typeof VariableInfoFlags.Free | typeof VariableInfoFlags.Normal | typeof VariableInfoFlags.Tagged} VariableInfoFlagsType */
+
+const VariableInfoFlags = Object.freeze({
+	Evaluated: 0b000,
+	Free: 0b001,
+	Normal: 0b010,
+	Tagged: 0b100
+});
+
 class VariableInfo {
 	/**
 	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
-	 * @param {string | true | undefined} freeName which free name the variable aliases, or true when none
+	 * @param {string | undefined} name which name the variable use, defined name or free name or tagged name
+	 * @param {VariableInfoFlagsType} flags how the variable is created
 	 * @param {TagInfo | undefined} tagInfo info about tags
 	 */
-	constructor(declaredScope, freeName, tagInfo) {
+	constructor(declaredScope, name, flags, tagInfo) {
 		this.declaredScope = declaredScope;
-		this.freeName = freeName;
+		this.name = name;
+		this.flags = flags;
 		this.tagInfo = tagInfo;
 	}
+
+	/**
+	 * @returns {boolean} the variable is free or not
+	 */
+	isFree() {
+		return (this.flags & VariableInfoFlags.Free) > 0;
+	}
+
+	/**
+	 * @returns {boolean} the variable is tagged by tagVariable or not
+	 */
+	isTagged() {
+		return (this.flags & VariableInfoFlags.Tagged) > 0;
+	}
 }
 
 /** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
@@ -1426,7 +1451,7 @@ class JavascriptParser extends Parser {
 			const info = this.getVariableInfo(/** @type {Identifier} */ (expr).name);
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo && typeof info.freeName === "string")
+				(info instanceof VariableInfo && (info.isFree() || info.isTagged()))
 			) {
 				return {
 					name: info,
@@ -1441,7 +1466,7 @@ class JavascriptParser extends Parser {
 			const info = this.getVariableInfo("this");
 			if (
 				typeof info === "string" ||
-				(info instanceof VariableInfo && typeof info.freeName === "string")
+				(info instanceof VariableInfo && (info.isFree() || info.isTagged()))
 			) {
 				return {
 					name: info,
@@ -1930,6 +1955,32 @@ class JavascriptParser extends Parser {
 		}
 	}
 
+	/**
+	 * Module pre walking iterates the scope for import entries
+	 * @param {(Statement | ModuleDeclaration)[]} statements statements
+	 */
+	modulePreWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			/** @type {StatementPath} */
+			(this.statementPath).push(statement);
+			switch (statement.type) {
+				case "ImportDeclaration":
+					this.modulePreWalkImportDeclaration(statement);
+					break;
+				case "ExportAllDeclaration":
+					this.modulePreWalkExportAllDeclaration(statement);
+					break;
+				case "ExportNamedDeclaration":
+					this.modulePreWalkExportNamedDeclaration(statement);
+					break;
+			}
+			this.prevStatement =
+				/** @type {StatementPath} */
+				(this.statementPath).pop();
+		}
+	}
+
 	/**
 	 * Pre walking iterates the scope for variable declarations
 	 * @param {(Statement | ModuleDeclaration)[]} statements statements
@@ -2050,12 +2101,6 @@ class JavascriptParser extends Parser {
 			return;
 		}
 		switch (statement.type) {
-			case "ImportDeclaration":
-				this.blockPreWalkImportDeclaration(statement);
-				break;
-			case "ExportAllDeclaration":
-				this.blockPreWalkExportAllDeclaration(statement);
-				break;
 			case "ExportDefaultDeclaration":
 				this.blockPreWalkExportDefaultDeclaration(statement);
 				break;
@@ -2595,7 +2640,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * @param {ImportDeclaration} statement statement
 	 */
-	blockPreWalkImportDeclaration(statement) {
+	modulePreWalkImportDeclaration(statement) {
 		const source = /** @type {ImportSource} */ (statement.source.value);
 		this.hooks.import.call(statement, source);
 		for (const specifier of statement.specifiers) {
@@ -2665,14 +2710,49 @@ class JavascriptParser extends Parser {
 	/**
 	 * @param {ExportNamedDeclaration} statement statement
 	 */
-	blockPreWalkExportNamedDeclaration(statement) {
-		let source;
-		if (statement.source) {
-			source = /** @type {ImportSource} */ (statement.source.value);
-			this.hooks.exportImport.call(statement, source);
-		} else {
-			this.hooks.export.call(statement);
+	modulePreWalkExportNamedDeclaration(statement) {
+		if (!statement.source) return;
+		const source = /** @type {ImportSource} */ (statement.source.value);
+		this.hooks.exportImport.call(statement, source);
+		if (statement.specifiers) {
+			for (
+				let specifierIndex = 0;
+				specifierIndex < statement.specifiers.length;
+				specifierIndex++
+			) {
+				const specifier = statement.specifiers[specifierIndex];
+				switch (specifier.type) {
+					case "ExportSpecifier": {
+						const localName =
+							/** @type {Identifier} */ (specifier.local).name ||
+							/** @type {string} */ (
+								/** @type {Literal} */ (specifier.local).value
+							);
+						const name =
+							/** @type {Identifier} */
+							(specifier.exported).name ||
+							/** @type {string} */
+							(/** @type {Literal} */ (specifier.exported).value);
+						this.hooks.exportImportSpecifier.call(
+							statement,
+							source,
+							localName,
+							name,
+							specifierIndex
+						);
+						break;
+					}
+				}
+			}
 		}
+	}
+
+	/**
+	 * @param {ExportNamedDeclaration} statement statement
+	 */
+	blockPreWalkExportNamedDeclaration(statement) {
+		if (statement.source) return;
+		this.hooks.export.call(statement);
 		if (
 			statement.declaration &&
 			!this.hooks.exportDeclaration.call(statement, statement.declaration)
@@ -2705,22 +2785,12 @@ class JavascriptParser extends Parser {
 							(specifier.exported).name ||
 							/** @type {string} */
 							(/** @type {Literal} */ (specifier.exported).value);
-						if (source) {
-							this.hooks.exportImportSpecifier.call(
-								statement,
-								source,
-								localName,
-								name,
-								specifierIndex
-							);
-						} else {
-							this.hooks.exportSpecifier.call(
-								statement,
-								localName,
-								name,
-								specifierIndex
-							);
-						}
+						this.hooks.exportSpecifier.call(
+							statement,
+							localName,
+							name,
+							specifierIndex
+						);
 						break;
 					}
 				}
@@ -2812,7 +2882,7 @@ class JavascriptParser extends Parser {
 	/**
 	 * @param {ExportAllDeclaration} statement statement
 	 */
-	blockPreWalkExportAllDeclaration(statement) {
+	modulePreWalkExportAllDeclaration(statement) {
 		const source = /** @type {ImportSource} */ (statement.source.value);
 		const name = statement.exported
 			? /** @type {Identifier} */
@@ -4053,13 +4123,13 @@ class JavascriptParser extends Parser {
 				}
 				tagInfo = tagInfo.next;
 			}
-			if (info.freeName === true) {
+			if (!info.isFree() && !info.isTagged()) {
 				if (defined !== undefined) {
 					return defined();
 				}
 				return;
 			}
-			name = info.freeName;
+			name = info.name;
 		}
 		const hook = hookMap.get(name);
 		if (hook !== undefined) {
@@ -4543,6 +4613,7 @@ class JavascriptParser extends Parser {
 		if (this.hooks.program.call(ast, comments) === undefined) {
 			this.destructuringAssignmentProperties = new WeakMap();
 			this.detectMode(ast.body);
+			this.modulePreWalkStatements(ast.body);
 			this.preWalkStatements(ast.body);
 			this.prevStatement = undefined;
 			this.blockPreWalkStatements(ast.body);
@@ -4818,25 +4889,31 @@ class JavascriptParser extends Parser {
 	 * @param {string} name name
 	 * @param {Tag} tag tag info
 	 * @param {TagData=} data data
+	 * @param {VariableInfoFlagsType=} flags flags
 	 */
-	tagVariable(name, tag, data) {
+	tagVariable(name, tag, data, flags = VariableInfoFlags.Tagged) {
 		const oldInfo = this.scope.definitions.get(name);
 		/** @type {VariableInfo} */
 		let newInfo;
 		if (oldInfo === undefined) {
-			newInfo = new VariableInfo(this.scope, name, {
+			newInfo = new VariableInfo(this.scope, name, flags, {
 				tag,
 				data,
 				next: undefined
 			});
 		} else if (oldInfo instanceof VariableInfo) {
-			newInfo = new VariableInfo(oldInfo.declaredScope, oldInfo.freeName, {
-				tag,
-				data,
-				next: oldInfo.tagInfo
-			});
+			newInfo = new VariableInfo(
+				oldInfo.declaredScope,
+				oldInfo.name,
+				/** @type {VariableInfoFlagsType} */ (oldInfo.flags | flags),
+				{
+					tag,
+					data,
+					next: oldInfo.tagInfo
+				}
+			);
 		} else {
-			newInfo = new VariableInfo(oldInfo, true, {
+			newInfo = new VariableInfo(oldInfo, name, flags, {
 				tag,
 				data,
 				next: undefined
@@ -4875,7 +4952,7 @@ class JavascriptParser extends Parser {
 		const info = this.scope.definitions.get(name);
 		if (info === undefined) return false;
 		if (info instanceof VariableInfo) {
-			return info.freeName === true;
+			return !info.isFree();
 		}
 		return true;
 	}
@@ -4904,7 +4981,12 @@ class JavascriptParser extends Parser {
 			} else {
 				this.scope.definitions.set(
 					name,
-					new VariableInfo(this.scope, variableInfo, undefined)
+					new VariableInfo(
+						this.scope,
+						variableInfo,
+						VariableInfoFlags.Free,
+						undefined
+					)
 				);
 			}
 		} else {
@@ -4917,7 +4999,12 @@ class JavascriptParser extends Parser {
 	 * @returns {VariableInfo} variable info
 	 */
 	evaluatedVariable(tagInfo) {
-		return new VariableInfo(this.scope, undefined, tagInfo);
+		return new VariableInfo(
+			this.scope,
+			undefined,
+			VariableInfoFlags.Evaluated,
+			tagInfo
+		);
 	}
 
 	/**
@@ -5002,9 +5089,27 @@ class JavascriptParser extends Parser {
 	getFreeInfoFromVariable(varName) {
 		const info = this.getVariableInfo(varName);
 		let name;
-		if (info instanceof VariableInfo) {
-			name = info.freeName;
-			if (typeof name !== "string") return;
+		if (info instanceof VariableInfo && info.name) {
+			if (!info.isFree()) return;
+			name = info.name;
+		} else if (typeof info !== "string") {
+			return;
+		} else {
+			name = info;
+		}
+		return { info, name };
+	}
+
+	/**
+	 * @param {string} varName variable name
+	 * @returns {{name: string, info: VariableInfo | string} | undefined} name of the free variable and variable info for that
+	 */
+	getNameInfoFromVariable(varName) {
+		const info = this.getVariableInfo(varName);
+		let name;
+		if (info instanceof VariableInfo && info.name) {
+			if (!info.isFree() && !info.isTagged()) return;
+			name = info.name;
 		} else if (typeof info !== "string") {
 			return;
 		} else {
@@ -5035,7 +5140,7 @@ class JavascriptParser extends Parser {
 				}
 				const rootName = getRootName(callee);
 				if (!rootName) return;
-				const result = this.getFreeInfoFromVariable(rootName);
+				const result = this.getNameInfoFromVariable(rootName);
 				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
 				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
@@ -5058,7 +5163,7 @@ class JavascriptParser extends Parser {
 				const rootName = getRootName(object);
 				if (!rootName) return;
 
-				const result = this.getFreeInfoFromVariable(rootName);
+				const result = this.getNameInfoFromVariable(rootName);
 				if (!result) return;
 				const { info: rootInfo, name: resolvedRoot } = result;
 				return {
@@ -5151,4 +5256,5 @@ module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
 module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
 	ALLOWED_MEMBER_TYPES_EXPRESSION;
 module.exports.VariableInfo = VariableInfo;
+module.exports.VariableInfoFlags = VariableInfoFlags;
 module.exports.getImportAttributes = getImportAttributes;

package/lib/library/ModuleLibraryPlugin.js

@@ -242,7 +242,6 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		{ factory, inlinedInIIFE },
 		libraryContext
 	) {
-		const result = new ConcatSource(source);
 		// Re-add `factoryExportsBinding` to the source
 		// when the module is rendered as a factory or treated as an inlined (startup) module but wrapped in an IIFE
 		if (
@@ -250,9 +249,9 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			module.buildMeta &&
 			module.buildMeta.factoryExportsBinding
 		) {
-			result.add(module.buildMeta.factoryExportsBinding);
+			return new ConcatSource(module.buildMeta.factoryExportsBinding, source);
 		}
-		return result;
+		return source;
 	}
 }
 

package/lib/optimize/ConcatenatedModule.js

@@ -1722,6 +1722,7 @@ class ConcatenatedModule extends Module {
 
 			if (onDemandExportsGeneration.call(this)) {
 				/** @type {BuildMeta} */ (this.buildMeta).factoryExportsBinding =
+					"\n// EXPORTS\n" +
 					`${RuntimeGlobals.definePropertyGetters}(${
 						this.exportsArgument
 					}, {${definitions.join(",")}\n});\n`;

package/lib/optimize/InnerGraph.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const { UsageState } = require("../ExportsInfo");
+const JavascriptParser = require("../javascript/JavascriptParser");
 
 /** @typedef {import("estree").Node} AnyNode */
 /** @typedef {import("../Dependency")} Dependency */
@@ -15,7 +16,6 @@ const { UsageState } = require("../ExportsInfo");
 /** @typedef {import("../ModuleGraphConnection")} ModuleGraphConnection */
 /** @typedef {import("../ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("../Parser").ParserState} ParserState */
-/** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
 /** @typedef {Map<TopLevelSymbol | null, Set<string | TopLevelSymbol> | true | undefined>} InnerGraph */
@@ -348,7 +348,12 @@ module.exports.tagTopLevelSymbol = (parser, name) => {
 	}
 
 	const fn = new TopLevelSymbol(name);
-	parser.tagVariable(name, topLevelSymbolTag, fn);
+	parser.tagVariable(
+		name,
+		topLevelSymbolTag,
+		fn,
+		JavascriptParser.VariableInfoFlags.Normal
+	);
 	return fn;
 };
 

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -101,16 +101,12 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				.getTreeRuntimeRequirements(chunk)
 				.has(RuntimeGlobals.ensureChunkIncludeEntries);
 			if (includeEntries) {
-				includedChunksMessages.push("sibling chunks for the entrypoint");
-				for (const c of chunkGraph.getChunkEntryDependentChunksIterable(
+				includedChunksMessages.push("chunks that the entrypoint depends on");
+				for (const c of chunkGraph.getRuntimeChunkDependentChunksIterable(
 					chunk
 				)) {
 					addChunk(c);
 				}
-				includedChunksMessages.push("chunks that the entrypoint depends on");
-				for (const c of chunkGraph.getChunkEntryDependOnChunksIterable(chunk)) {
-					addChunk(c);
-				}
 			}
 		}
 		for (const entrypoint of chunk.getAllReferencedAsyncEntrypoints()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webpack",
-  "version": "5.101.1",
+  "version": "5.101.2",
   "description": "Packs ECMAScript/CommonJs/AMD modules for the browser. Allows you to split your codebase into multiple bundles, which can be loaded on demand. Supports loaders to preprocess files, i.e. json, jsx, es7, css, less, ... and your custom stuff.",
   "homepage": "https://github.com/webpack/webpack",
   "bugs": "https://github.com/webpack/webpack/issues",

package/types.d.ts

@@ -1373,7 +1373,7 @@ declare class ChunkGraph {
 	getNumberOfRuntimeModules(chunk: Chunk): number;
 	getChunkEntryModulesIterable(chunk: Chunk): Iterable<Module>;
 	getChunkEntryDependentChunksIterable(chunk: Chunk): Iterable<Chunk>;
-	getChunkEntryDependOnChunksIterable(chunk: Chunk): Iterable<Chunk>;
+	getRuntimeChunkDependentChunksIterable(chunk: Chunk): Iterable<Chunk>;
 	hasChunkEntryDependentChunks(chunk: Chunk): boolean;
 	getChunkRuntimeModulesIterable(chunk: Chunk): Iterable<RuntimeModule>;
 	getChunkRuntimeModulesInOrder(chunk: Chunk): RuntimeModule[];
@@ -4534,6 +4534,8 @@ declare abstract class Entrypoint extends ChunkGroup {
 	 * (or at least the execution of them)
 	 */
 	getEntrypointChunk(): Chunk;
+	addDependOn(entrypoint: Entrypoint): void;
+	dependOn(entrypoint: Entrypoint): boolean;
 }
 type EnumValue =
 	| null
@@ -7054,6 +7056,40 @@ declare class JavascriptParser extends ParserClass {
 		classy: ClassExpression | ClassDeclaration | MaybeNamedClassDeclaration
 	): void;
 
+	/**
+	 * Module pre walking iterates the scope for import entries
+	 */
+	modulePreWalkStatements(
+		statements: (
+			| ImportDeclarationJavascriptParser
+			| ExportNamedDeclarationJavascriptParser
+			| ExportAllDeclarationJavascriptParser
+			| FunctionDeclaration
+			| VariableDeclaration
+			| ClassDeclaration
+			| ExpressionStatement
+			| BlockStatement
+			| StaticBlock
+			| EmptyStatement
+			| DebuggerStatement
+			| WithStatement
+			| ReturnStatement
+			| LabeledStatement
+			| BreakStatement
+			| ContinueStatement
+			| IfStatement
+			| SwitchStatement
+			| ThrowStatement
+			| TryStatement
+			| WhileStatement
+			| DoWhileStatement
+			| ForStatement
+			| ForInStatement
+			| ForOfStatement
+			| ExportDefaultDeclaration
+		)[]
+	): void;
+
 	/**
 	 * Pre walking iterates the scope for variable declarations
 	 */
@@ -7293,13 +7329,16 @@ declare class JavascriptParser extends ParserClass {
 	): void;
 	blockPreWalkExpressionStatement(statement: ExpressionStatement): void;
 	preWalkAssignmentExpression(expression: AssignmentExpression): void;
-	blockPreWalkImportDeclaration(
+	modulePreWalkImportDeclaration(
 		statement: ImportDeclarationJavascriptParser
 	): void;
 	enterDeclaration(
 		declaration: Declaration,
 		onIdent: (ident: string, identifier: Identifier) => void
 	): void;
+	modulePreWalkExportNamedDeclaration(
+		statement: ExportNamedDeclarationJavascriptParser
+	): void;
 	blockPreWalkExportNamedDeclaration(
 		statement: ExportNamedDeclarationJavascriptParser
 	): void;
@@ -7310,7 +7349,7 @@ declare class JavascriptParser extends ParserClass {
 		statement: ExportDefaultDeclaration
 	): void;
 	walkExportDefaultDeclaration(statement: ExportDefaultDeclaration): void;
-	blockPreWalkExportAllDeclaration(
+	modulePreWalkExportAllDeclaration(
 		statement: ExportAllDeclarationJavascriptParser
 	): void;
 	preWalkVariableDeclaration(statement: VariableDeclaration): void;
@@ -7716,7 +7755,12 @@ declare class JavascriptParser extends ParserClass {
 	unsetAsiPosition(pos: number): void;
 	isStatementLevelExpression(expr: Expression): boolean;
 	getTagData(name: string, tag: symbol): undefined | TagData;
-	tagVariable(name: string, tag: symbol, data?: TagData): void;
+	tagVariable(
+		name: string,
+		tag: symbol,
+		data?: TagData,
+		flags?: 0 | 1 | 2 | 4
+	): void;
 	defineVariable(name: string): void;
 	undefineVariable(name: string): void;
 	isVariableDefined(name: string): boolean;
@@ -7794,6 +7838,9 @@ declare class JavascriptParser extends ParserClass {
 	getFreeInfoFromVariable(
 		varName: string
 	): undefined | { name: string; info: string | VariableInfo };
+	getNameInfoFromVariable(
+		varName: string
+	): undefined | { name: string; info: string | VariableInfo };
 	getMemberExpressionInfo(
 		expression:
 			| ImportExpressionImport
@@ -7842,6 +7889,12 @@ declare class JavascriptParser extends ParserClass {
 	static ALLOWED_MEMBER_TYPES_CALL_EXPRESSION: 1;
 	static ALLOWED_MEMBER_TYPES_EXPRESSION: 2;
 	static VariableInfo: typeof VariableInfo;
+	static VariableInfoFlags: Readonly<{
+		Evaluated: 0;
+		Free: 1;
+		Normal: 2;
+		Tagged: 4;
+	}>;
 	static getImportAttributes: (
 		node:
 			| ImportDeclarationJavascriptParser
@@ -16949,13 +17002,18 @@ declare interface Values {
 declare class VariableInfo {
 	constructor(
 		declaredScope: ScopeInfo,
-		freeName?: string | true,
+		name: undefined | string,
+		flags: VariableInfoFlagsType,
 		tagInfo?: TagInfo
 	);
 	declaredScope: ScopeInfo;
-	freeName?: string | true;
+	name?: string;
+	flags: VariableInfoFlagsType;
 	tagInfo?: TagInfo;
+	isFree(): boolean;
+	isTagged(): boolean;
 }
+type VariableInfoFlagsType = 0 | 1 | 2 | 4;
 declare interface VirtualModuleConfig {
 	/**
 	 * - The module type