webpack 5.101.2 → 5.102.0

package/lib/javascript/JavascriptParser.js

@@ -24,7 +24,6 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").BlockStatement} BlockStatement */
 /** @typedef {import("estree").SequenceExpression} SequenceExpression */
 /** @typedef {import("estree").CallExpression} CallExpression */
-/** @typedef {import("estree").BaseCallExpression} BaseCallExpression */
 /** @typedef {import("estree").StaticBlock} StaticBlock */
 /** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
 /** @typedef {import("estree").ForStatement} ForStatement */
@@ -36,6 +35,8 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").PrivateIdentifier} PrivateIdentifier */
 /** @typedef {import("estree").PropertyDefinition} PropertyDefinition */
 /** @typedef {import("estree").Expression} Expression */
+/** @typedef {import("estree").ImportAttribute} ImportAttribute */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
 /** @typedef {import("estree").Identifier} Identifier */
 /** @typedef {import("estree").VariableDeclaration} VariableDeclaration */
 /** @typedef {import("estree").IfStatement} IfStatement */
@@ -48,7 +49,6 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").MetaProperty} MetaProperty */
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").AssignmentPattern} AssignmentPattern */
-/** @typedef {import("estree").ChainElement} ChainElement */
 /** @typedef {import("estree").Pattern} Pattern */
 /** @typedef {import("estree").UpdateExpression} UpdateExpression */
 /** @typedef {import("estree").ObjectExpression} ObjectExpression */
@@ -74,6 +74,8 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").WhileStatement} WhileStatement */
 /** @typedef {import("estree").ArrowFunctionExpression} ArrowFunctionExpression */
 /** @typedef {import("estree").ExpressionStatement} ExpressionStatement */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
 /** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
 /** @typedef {import("estree").DoWhileStatement} DoWhileStatement */
 /** @typedef {import("estree").TryStatement} TryStatement */
@@ -83,10 +85,9 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").Statement} Statement */
 /** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */
 /** @typedef {import("estree").Super} Super */
-/** @typedef {import("estree").ImportSpecifier} ImportSpecifier */
 /** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression */
 /** @typedef {import("estree").TemplateLiteral} TemplateLiteral */
-/** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
 /** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
 /** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
 /**
@@ -95,19 +96,17 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
  */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[] }} GetInfoResult */
+
+/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges }} GetInfoResult */
 /** @typedef {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} StatementPathItem */
 /** @typedef {(ident: string) => void} OnIdentString */
 /** @typedef {(ident: string, identifier: Identifier) => void} OnIdent */
 /** @typedef {StatementPathItem[]} StatementPath */
 
+/** @typedef {Set<DestructuringAssignmentProperty>} DestructuringAssignmentProperties */
+
 // TODO remove cast when @types/estree has been updated to import assertions
-/** @typedef {import("estree").BaseNode & { type: "ImportAttribute", key: Identifier | Literal, value: Literal }} ImportAttribute */
-/** @typedef {import("estree").ImportDeclaration & { attributes?: Array<ImportAttribute>, phase?: "defer" }} ImportDeclaration */
-/** @typedef {import("estree").ExportNamedDeclaration & { attributes?: Array<ImportAttribute> }} ExportNamedDeclaration */
-/** @typedef {import("estree").ExportAllDeclaration & { attributes?: Array<ImportAttribute> }} ExportAllDeclaration */
 /** @typedef {import("estree").ImportExpression & { options?: Expression | null, phase?: "defer" }} ImportExpression */
-/** @typedef {ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration} ModuleDeclaration */
 
 /** @type {string[]} */
 const EMPTY_ARRAY = [];
@@ -301,7 +300,15 @@ class VariableInfo {
 /** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
 
 /** @typedef {symbol} Tag */
-/** @typedef {Record<string, TODO>} TagData */
+
+/** @typedef {import("../dependencies/HarmonyImportDependencyParserPlugin").HarmonySettings} HarmonySettings */
+/** @typedef {import("../dependencies/ImportParserPlugin").ImportSettings} ImportSettings */
+/** @typedef {import("../dependencies/CommonJsImportsParserPlugin").CommonJsImportSettings} CommonJsImportSettings */
+/** @typedef {import("../CompatibilityPlugin").CompatibilitySettings} CompatibilitySettings */
+/** @typedef {import("../optimize/InnerGraph").TopLevelSymbol} TopLevelSymbol */
+
+/** @typedef {HarmonySettings | ImportSettings | CommonJsImportSettings | TopLevelSymbol | CompatibilitySettings} KnownTagData */
+/** @typedef {KnownTagData | Record<string, EXPECTED_ANY>} TagData */
 
 /**
  * @typedef {object} TagInfo
@@ -310,6 +317,11 @@ class VariableInfo {
  * @property {TagInfo | undefined} next
  */
 
+/** @typedef {string[]} CalleeMembers */
+/** @typedef {string[]} Members */
+/** @typedef {boolean[]} MembersOptionals */
+/** @typedef {Range[]} MemberRanges */
+
 const SCOPE_INFO_TERMINATED_RETURN = 1;
 const SCOPE_INFO_TERMINATED_THROW = 2;
 
@@ -330,7 +342,8 @@ const SCOPE_INFO_TERMINATED_THROW = 2;
 /**
  * @typedef {object} DestructuringAssignmentProperty
  * @property {string} id
- * @property {Range | undefined=} range
+ * @property {Range} range
+ * @property {Set<DestructuringAssignmentProperty> | undefined=} pattern
  * @property {boolean | string} shorthand
  */
 
@@ -359,7 +372,7 @@ const joinRanges = (startRange, endRange) => {
  * Helper function used to generate a string representation of a
  * [member expression](https://github.com/estree/estree/blob/master/es5.md#memberexpression).
  * @param {string} object object to name
- * @param {string[]} membersReversed reversed list of members
+ * @param {Members} membersReversed reversed list of members
  * @returns {string} member expression as a string
  * @example
  * ```js
@@ -522,26 +535,30 @@ class JavascriptParser extends Parser {
 			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
 			/** @type {HookMap<SyncBailHook<[Identifier], boolean | void>>} */
 			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
+			/** @type {SyncBailHook<[Expression], boolean | void>} */
+			collectDestructuringAssignmentProperties: new SyncBailHook([
+				"expression"
+			]),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
 			/** @type {HookMap<SyncBailHook<[AssignmentExpression], boolean | void>>} */
 			assign: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[AssignmentExpression, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[AssignmentExpression, Members], boolean | void>>} */
 			assignMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			typeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {SyncBailHook<[ImportExpression], boolean | void>} */
-			importCall: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ImportExpression, CallExpression?], boolean | void>} */
+			importCall: new SyncBailHook(["expression", "importThen"]),
 			/** @type {SyncBailHook<[Expression | ForOfStatement], boolean | void>} */
 			topLevelAwait: new SyncBailHook(["expression"]),
 			/** @type {HookMap<SyncBailHook<[CallExpression], boolean | void>>} */
 			call: new HookMap(() => new SyncBailHook(["expression"])),
 			/** Something like "a.b()" */
-			/** @type {HookMap<SyncBailHook<[CallExpression, string[], boolean[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, Members, MembersOptionals, MemberRanges], boolean | void>>} */
 			callMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -552,7 +569,7 @@ class JavascriptParser extends Parser {
 					])
 			),
 			/** Something like "a.b().c.d" */
-			/** @type {HookMap<SyncBailHook<[Expression, string[], CallExpression, string[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[Expression, CalleeMembers, CallExpression, Members, MemberRanges], boolean | void>>} */
 			memberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -564,7 +581,7 @@ class JavascriptParser extends Parser {
 					])
 			),
 			/** Something like "a.b().c.d()"" */
-			/** @type {HookMap<SyncBailHook<[CallExpression, string[], CallExpression, string[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, CalleeMembers, CallExpression, Members, MemberRanges], boolean | void>>} */
 			callMemberChainOfCallMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -583,7 +600,7 @@ class JavascriptParser extends Parser {
 			binaryExpression: new SyncBailHook(["binaryExpression"]),
 			/** @type {HookMap<SyncBailHook<[Expression], boolean | void>>} */
 			expression: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[MemberExpression, string[], boolean[], Range[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[MemberExpression, Members, MembersOptionals, MemberRanges], boolean | void>>} */
 			expressionMemberChain: new HookMap(
 				() =>
 					new SyncBailHook([
@@ -593,7 +610,7 @@ class JavascriptParser extends Parser {
 						"memberRanges"
 					])
 			),
-			/** @type {HookMap<SyncBailHook<[MemberExpression, string[]], boolean | void>>} */
+			/** @type {HookMap<SyncBailHook<[MemberExpression, Members], boolean | void>>} */
 			unhandledExpressionMemberChain: new HookMap(
 				() => new SyncBailHook(["expression", "members"])
 			),
@@ -612,9 +629,9 @@ class JavascriptParser extends Parser {
 		});
 		this.sourceType = sourceType;
 		/** @type {ScopeInfo} */
-		this.scope = /** @type {TODO} */ (undefined);
+		this.scope = /** @type {EXPECTED_ANY} */ (undefined);
 		/** @type {ParserState} */
-		this.state = /** @type {TODO} */ (undefined);
+		this.state = /** @type {EXPECTED_ANY} */ (undefined);
 		/** @type {Comment[] | undefined} */
 		this.comments = undefined;
 		/** @type {Set<number> | undefined} */
@@ -623,7 +640,7 @@ class JavascriptParser extends Parser {
 		this.statementPath = undefined;
 		/** @type {Statement | ModuleDeclaration | Expression | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | undefined} */
 		this.prevStatement = undefined;
-		/** @type {WeakMap<Expression, Set<DestructuringAssignmentProperty>> | undefined} */
+		/** @type {WeakMap<Expression, DestructuringAssignmentProperties> | undefined} */
 		this.destructuringAssignmentProperties = undefined;
 		/** @type {TagData | undefined} */
 		this.currentTagData = undefined;
@@ -1887,7 +1904,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Expression} node node
-	 * @returns {Set<DestructuringAssignmentProperty> | undefined} destructured identifiers
+	 * @returns {DestructuringAssignmentProperties | undefined} destructured identifiers
 	 */
 	destructuringAssignmentPropertiesFor(node) {
 		if (!this.destructuringAssignmentProperties) return;
@@ -2607,34 +2624,48 @@ class JavascriptParser extends Parser {
 	 * @param {AssignmentExpression} expression assignment expression
 	 */
 	preWalkAssignmentExpression(expression) {
+		this.enterDestructuringAssignment(expression.left, expression.right);
+	}
+
+	/**
+	 * @param {Pattern} pattern pattern
+	 * @param {Expression} expression assignment expression
+	 * @returns {Expression | undefined} destructuring expression
+	 */
+	enterDestructuringAssignment(pattern, expression) {
 		if (
-			expression.left.type !== "ObjectPattern" ||
+			pattern.type !== "ObjectPattern" ||
 			!this.destructuringAssignmentProperties
 		) {
 			return;
 		}
-		const keys = this._preWalkObjectPattern(expression.left);
-		if (!keys) return;
-
-		// check multiple assignments
-		if (this.destructuringAssignmentProperties.has(expression)) {
-			const set =
-				/** @type {Set<DestructuringAssignmentProperty>} */
-				(this.destructuringAssignmentProperties.get(expression));
-			this.destructuringAssignmentProperties.delete(expression);
-			for (const id of set) keys.add(id);
-		}
 
-		this.destructuringAssignmentProperties.set(
-			expression.right.type === "AwaitExpression"
-				? expression.right.argument
-				: expression.right,
-			keys
-		);
+		const expr =
+			expression.type === "AwaitExpression" ? expression.argument : expression;
+
+		const destructuring =
+			expr.type === "AssignmentExpression"
+				? this.enterDestructuringAssignment(expr.left, expr.right)
+				: this.hooks.collectDestructuringAssignmentProperties.call(expr)
+					? expr
+					: undefined;
+
+		if (destructuring) {
+			const keys = this._preWalkObjectPattern(pattern);
+			if (!keys) return;
 
-		if (expression.right.type === "AssignmentExpression") {
-			this.preWalkAssignmentExpression(expression.right);
+			// check multiple assignments
+			if (this.destructuringAssignmentProperties.has(destructuring)) {
+				const set =
+					/** @type {DestructuringAssignmentProperties} */
+					(this.destructuringAssignmentProperties.get(destructuring));
+				for (const id of keys) set.add(id);
+			} else {
+				this.destructuringAssignmentProperties.set(destructuring, keys);
+			}
 		}
+
+		return destructuring;
 	}
 
 	/**
@@ -2811,11 +2842,16 @@ class JavascriptParser extends Parser {
 	 * @param {ExportDefaultDeclaration} statement statement
 	 */
 	blockPreWalkExportDefaultDeclaration(statement) {
-		const prev = this.prevStatement;
+		if (
+			statement.declaration.type === "FunctionDeclaration" ||
+			statement.declaration.type === "ClassDeclaration"
+		) {
+			const prev = this.prevStatement;
 
-		this.preWalkStatement(/** @type {TODO} */ (statement.declaration));
-		this.prevStatement = prev;
-		this.blockPreWalkStatement(/** @type {TODO} */ (statement.declaration));
+			this.preWalkStatement(statement.declaration);
+			this.prevStatement = prev;
+			this.blockPreWalkStatement(statement.declaration);
+		}
 
 		if (
 			/** @type {MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
@@ -2867,15 +2903,7 @@ class JavascriptParser extends Parser {
 				this.walkExpression(statement.declaration);
 			}
 
-			if (!this.hooks.exportExpression.call(statement, statement.declaration)) {
-				this.hooks.exportSpecifier.call(
-					statement,
-					/** @type {TODO} */
-					(statement.declaration),
-					"default",
-					undefined
-				);
-			}
+			this.hooks.exportExpression.call(statement, statement.declaration);
 		}
 	}
 
@@ -2945,10 +2973,10 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {ObjectPattern} objectPattern object pattern
-	 * @returns {Set<DestructuringAssignmentProperty> | undefined} set of names or undefined if not all keys are identifiers
+	 * @returns {DestructuringAssignmentProperties | undefined} set of names or undefined if not all keys are identifiers
 	 */
 	_preWalkObjectPattern(objectPattern) {
-		/** @type {Set<DestructuringAssignmentProperty>} */
+		/** @type {DestructuringAssignmentProperties} */
 		const props = new Set();
 		const properties = objectPattern.properties;
 		for (let i = 0; i < properties.length; i++) {
@@ -2966,18 +2994,32 @@ class JavascriptParser extends Parser {
 			}
 			const key = property.key;
 			if (key.type === "Identifier" && !property.computed) {
+				const pattern =
+					property.value.type === "ObjectPattern"
+						? this._preWalkObjectPattern(property.value)
+						: property.value.type === "ArrayPattern"
+							? this._preWalkArrayPattern(property.value)
+							: undefined;
 				props.add({
 					id: key.name,
-					range: key.range,
+					range: /** @type {Range} */ (key.range),
+					pattern,
 					shorthand: this.scope.inShorthand
 				});
 			} else {
 				const id = this.evaluateExpression(key);
 				const str = id.asString();
 				if (str) {
+					const pattern =
+						property.value.type === "ObjectPattern"
+							? this._preWalkObjectPattern(property.value)
+							: property.value.type === "ArrayPattern"
+								? this._preWalkArrayPattern(property.value)
+								: undefined;
 					props.add({
 						id: str,
-						range: key.range,
+						range: /** @type {Range} */ (key.range),
+						pattern,
 						shorthand: this.scope.inShorthand
 					});
 				} else {
@@ -2992,28 +3034,40 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {VariableDeclarator} declarator variable declarator
+	 * @param {ArrayPattern} arrayPattern array pattern
+	 * @returns {Set<DestructuringAssignmentProperty> | undefined} set of names or undefined if not all keys are identifiers
 	 */
-	preWalkVariableDeclarator(declarator) {
-		if (
-			!declarator.init ||
-			declarator.id.type !== "ObjectPattern" ||
-			!this.destructuringAssignmentProperties
-		) {
-			return;
+	_preWalkArrayPattern(arrayPattern) {
+		/** @type {Set<DestructuringAssignmentProperty>} */
+		const props = new Set();
+		const elements = arrayPattern.elements;
+		for (let i = 0; i < elements.length; i++) {
+			const element = elements[i];
+			if (!element) continue;
+			if (element.type === "RestElement") return;
+			const pattern =
+				element.type === "ObjectPattern"
+					? this._preWalkObjectPattern(element)
+					: element.type === "ArrayPattern"
+						? this._preWalkArrayPattern(element)
+						: undefined;
+			props.add({
+				id: `${i}`,
+				range: /** @type {Range} */ (element.range),
+				pattern,
+				shorthand: false
+			});
 		}
-		const keys = this._preWalkObjectPattern(declarator.id);
-
-		if (!keys) return;
-		this.destructuringAssignmentProperties.set(
-			declarator.init.type === "AwaitExpression"
-				? declarator.init.argument
-				: declarator.init,
-			keys
-		);
 
-		if (declarator.init.type === "AssignmentExpression") {
-			this.preWalkAssignmentExpression(declarator.init);
+		return props;
+	}
+
+	/**
+	 * @param {VariableDeclarator} declarator variable declarator
+	 */
+	preWalkVariableDeclarator(declarator) {
+		if (declarator.init) {
+			this.enterDestructuringAssignment(declarator.id, declarator.init);
 		}
 	}
 
@@ -3832,6 +3886,18 @@ class JavascriptParser extends Parser {
 					);
 					if (result === true) return;
 				}
+				// import("./m").then(m => { ... })
+				if (
+					expression.callee.object.type === "ImportExpression" &&
+					expression.callee.property.type === "Identifier" &&
+					expression.callee.property.name === "then"
+				) {
+					const result = this.hooks.importCall.call(
+						expression.callee.object,
+						expression
+					);
+					if (result === true) return;
+				}
 			}
 			const callee = this.evaluateExpression(expression.callee);
 			if (callee.isIdentifier()) {
@@ -3944,7 +4010,7 @@ class JavascriptParser extends Parser {
 	 * @param {MemberExpression} expression member expression
 	 * @param {string} name name
 	 * @param {string | VariableInfo} rootInfo root info
-	 * @param {string[]} members members
+	 * @param {Members} members members
 	 * @param {() => R | undefined} onUnhandled on unhandled callback
 	 */
 	walkMemberExpressionWithExpressionName(
@@ -4026,7 +4092,7 @@ class JavascriptParser extends Parser {
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {Expression | Super} expr expression info
-	 * @param {((name: string, rootInfo: string | ScopeInfo | VariableInfo, getMembers: () => string[]) => R) | undefined} fallback callback when variable in not handled by hooks
+	 * @param {((name: string, rootInfo: string | ScopeInfo | VariableInfo, getMembers: () => Members) => R) | undefined} fallback callback when variable in not handled by hooks
 	 * @param {((result?: string) => R | undefined) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
@@ -4097,7 +4163,7 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {ExportedVariableInfo} info variable info
 	 * @param {((name: string) => R | undefined) | undefined} fallback callback when variable in not handled by hooks
-	 * @param {((result?: string) => TODO) | undefined} defined callback when variable is defined
+	 * @param {((result?: string) => R | undefined) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
@@ -4285,7 +4351,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Array<Directive | Statement | ModuleDeclaration>} statements statements
+	 * @param {(Directive | Statement | ModuleDeclaration)[]} statements statements
 	 */
 	detectMode(statements) {
 		const isLiteral =
@@ -4605,7 +4671,7 @@ class JavascriptParser extends Parser {
 			terminated: undefined,
 			definitions: new StackedMap()
 		};
-		this.state = /** @type {ParserState} */ (state);
+		this.state = state;
 		this.comments = comments;
 		this.semicolons = semicolons;
 		this.statementPath = [];
@@ -4959,7 +5025,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name variable name
-	 * @returns {string | ExportedVariableInfo} info for this variable
+	 * @returns {ExportedVariableInfo} info for this variable
 	 */
 	getVariableInfo(name) {
 		const value = this.scope.definitions.get(name);
@@ -4971,7 +5037,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name variable name
-	 * @param {string | ExportedVariableInfo} variableInfo new info for this variable
+	 * @param {ExportedVariableInfo} variableInfo new info for this variable
 	 * @returns {void}
 	 */
 	setVariable(name, variableInfo) {
@@ -5052,7 +5118,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Expression | Super} expression a member expression
-	 * @returns {{ members: string[], object: Expression | Super, membersOptionals: boolean[], memberRanges: Range[] }} member names (reverse order) and remaining object
+	 * @returns {{ members: Members, object: Expression | Super, membersOptionals: MembersOptionals, memberRanges: MemberRanges }} member names (reverse order) and remaining object
 	 */
 	extractMemberExpressionChain(expression) {
 		/** @type {Node} */
@@ -5118,8 +5184,8 @@ class JavascriptParser extends Parser {
 		return { info, name };
 	}
 
-	/** @typedef {{ type: "call", call: CallExpression, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[]}} CallExpressionInfo */
-	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[]}} ExpressionExpressionInfo */
+	/** @typedef {{ type: "call", call: CallExpression, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => CalleeMembers, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges}} CallExpressionInfo */
+	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => Members, getMembersOptionals: () => MembersOptionals, getMemberRanges: () => MemberRanges}} ExpressionExpressionInfo */
 
 	/**
 	 * @param {Expression | Super} expression a member expression
@@ -5179,8 +5245,8 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {MemberExpression} expression an expression
-	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]} | undefined} name info
+	 * @param {Expression} expression an expression
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => Members} | undefined} name info
 	 */
 	getNameForExpression(expression) {
 		return this.getMemberExpressionInfo(

package/lib/javascript/JavascriptParserHelpers.js

@@ -10,10 +10,10 @@ const ConstDependency = require("../dependencies/ConstDependency");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
 /** @typedef {import("estree").Expression} Expression */
-/** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").SourceLocation} SourceLocation */
 /** @typedef {import("./JavascriptParser")} JavascriptParser */
 /** @typedef {import("./JavascriptParser").Range} Range */
+/** @typedef {import("./BasicEvaluatedExpression").GetMembers} GetMembers */
 
 module.exports.approve = () => true;
 
@@ -31,7 +31,7 @@ module.exports.evaluateToBoolean = (value) =>
 /**
  * @param {string} identifier identifier
  * @param {string} rootInfo rootInfo
- * @param {() => string[]} getMembers getMembers
+ * @param {GetMembers} getMembers getMembers
  * @param {boolean | null=} truthy is truthy, null if nullish
  * @returns {(expression: Expression) => BasicEvaluatedExpression} callback
  */

package/lib/javascript/StartupHelpers.js

@@ -13,14 +13,11 @@ const { getAllChunks } = require("./ChunkHelpers");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Chunk").ChunkId} ChunkId */
-/** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../ChunkGraph").ModuleId} ModuleId */
 /** @typedef {import("../Entrypoint")} Entrypoint */
 /** @typedef {import("../ChunkGraph").EntryModuleWithChunkGroup} EntryModuleWithChunkGroup */
-/** @typedef {import("../ChunkGroup")} ChunkGroup */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {(string|number)[]} EntryItem */
 
 const EXPORT_PREFIX = `var ${RuntimeGlobals.exports} = `;
 
@@ -137,9 +134,10 @@ module.exports.generateEntryStartup = (
  * @param {Chunk} chunk the chunk
  * @param {ChunkGraph} chunkGraph the chunk graph
  * @param {(chunk: Chunk, chunkGraph: ChunkGraph) => boolean} filterFn filter function
- * @returns {Set<number | string>} initially fulfilled chunk ids
+ * @returns {Set<ChunkId>} initially fulfilled chunk ids
  */
 module.exports.getInitialChunkIds = (chunk, chunkGraph, filterFn) => {
+	/** @type {Set<ChunkId>} */
 	const initialChunkIds = new Set(chunk.ids);
 	for (const c of chunk.getAllInitialChunks()) {
 		if (c === chunk || filterFn(c, chunkGraph)) continue;

package/lib/json/JsonData.js

@@ -10,7 +10,7 @@ const { register } = require("../util/serialization");
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
 
 class JsonData {
 	/**

package/lib/json/JsonGenerator.js

@@ -20,10 +20,9 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 /** @typedef {import("../Module").SourceTypes} SourceTypes */
 /** @typedef {import("../NormalModule")} NormalModule */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./JsonData")} JsonData */
-/** @typedef {import("./JsonModulesPlugin").JsonArray} JsonArray */
-/** @typedef {import("./JsonModulesPlugin").JsonObject} JsonObject */
-/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
+/** @typedef {import("../util/fs").JsonArray} JsonArray */
+/** @typedef {import("../util/fs").JsonObject} JsonObject */
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
 
 /**
  * @param {JsonValue} data Raw JSON data
@@ -206,7 +205,7 @@ class JsonGenerator extends Generator {
 		/** @type {string} */
 		let content;
 		if (concatenationScope) {
-			content = `${runtimeTemplate.supportsConst() ? "const" : "var"} ${
+			content = `${runtimeTemplate.renderConst()} ${
 				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
 			} = ${jsonExpr};`;
 			concatenationScope.registerNamespaceExport(

package/lib/json/JsonModulesPlugin.js

@@ -11,9 +11,6 @@ const JsonGenerator = require("./JsonGenerator");
 const JsonParser = require("./JsonParser");
 
 /** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../util/fs").JsonArray} JsonArray */
-/** @typedef {import("../util/fs").JsonObject} JsonObject */
-/** @typedef {import("../util/fs").JsonValue} JsonValue */
 
 const validate = createSchemaValidation(
 	require("../../schemas/plugins/json/JsonModulesPluginParser.check"),

package/lib/json/JsonParser.js

@@ -15,7 +15,9 @@ const JsonData = require("./JsonData");
 /** @typedef {import("../Module").BuildMeta} BuildMeta */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-/** @typedef {import("./JsonModulesPlugin").JsonValue} JsonValue */
+/** @typedef {import("../util/fs").JsonValue} JsonValue */
+
+/** @typedef {(input: string) => Buffer | JsonValue} ParseFn */
 
 const getParseJson = memoize(() => require("json-parse-even-better-errors"));
 
@@ -38,7 +40,7 @@ class JsonParser extends Parser {
 			source = source.toString("utf8");
 		}
 
-		/** @type {NonNullable<JsonModulesPluginParserOptions["parse"]>} */
+		/** @type {ParseFn} */
 		const parseFn =
 			typeof this.options.parse === "function"
 				? this.options.parse