webpack 5.95.0 → 5.96.1

package/lib/javascript/JavascriptParser.js

@@ -5,13 +5,16 @@
 
 "use strict";
 
-const { Parser: AcornParser } = require("acorn");
-const { importAttributesOrAssertions } = require("acorn-import-attributes");
+const { Parser: AcornParser, tokTypes } = require("acorn");
 const { SyncBailHook, HookMap } = require("tapable");
 const vm = require("vm");
 const Parser = require("../Parser");
 const StackedMap = require("../util/StackedMap");
 const binarySearchBounds = require("../util/binarySearchBounds");
+const {
+	webpackCommentRegExp,
+	createMagicCommentContext
+} = require("../util/magicComment");
 const memoize = require("../util/memoize");
 const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 
@@ -23,11 +26,9 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("estree").BaseCallExpression} BaseCallExpression */
 /** @typedef {import("estree").StaticBlock} StaticBlock */
-/** @typedef {import("estree").ImportExpression} ImportExpression */
 /** @typedef {import("estree").ClassDeclaration} ClassDeclaration */
 /** @typedef {import("estree").ForStatement} ForStatement */
 /** @typedef {import("estree").SwitchStatement} SwitchStatement */
-/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclaration */
 /** @typedef {import("estree").ClassExpression} ClassExpression */
 /** @typedef {import("estree").Comment} Comment */
 /** @typedef {import("estree").ConditionalExpression} ConditionalExpression */
@@ -67,7 +68,6 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").WithStatement} WithStatement */
 /** @typedef {import("estree").ThrowStatement} ThrowStatement */
 /** @typedef {import("estree").MethodDefinition} MethodDefinition */
-/** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
 /** @typedef {import("estree").NewExpression} NewExpression */
 /** @typedef {import("estree").SpreadElement} SpreadElement */
 /** @typedef {import("estree").FunctionExpression} FunctionExpression */
@@ -77,13 +77,11 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
 /** @typedef {import("estree").FunctionDeclaration} FunctionDeclaration */
 /** @typedef {import("estree").DoWhileStatement} DoWhileStatement */
 /** @typedef {import("estree").TryStatement} TryStatement */
-/** @typedef {import("estree").Node} AnyNode */
+/** @typedef {import("estree").Node} Node */
 /** @typedef {import("estree").Program} Program */
 /** @typedef {import("estree").Directive} Directive */
 /** @typedef {import("estree").Statement} Statement */
-/** @typedef {import("estree").ImportDeclaration} ImportDeclaration */
 /** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclaration */
-/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclaration */
 /** @typedef {import("estree").Super} Super */
 /** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpression */
 /** @typedef {import("estree").TemplateLiteral} TemplateLiteral */
@@ -94,12 +92,20 @@ const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
  */
 /** @typedef {import("../Parser").ParserState} ParserState */
 /** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
-/** @typedef {{declaredScope: ScopeInfo, freeName: string | true, tagInfo: TagInfo | undefined}} VariableInfoInterface */
+/** @typedef {{declaredScope: ScopeInfo, freeName: string | true | undefined, tagInfo: TagInfo | undefined}} VariableInfoInterface */
 /** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[] }} GetInfoResult */
 /** @typedef {Statement | ModuleDeclaration | Expression} StatementPathItem */
-/** @typedef {TODO} OnIdent */
-
-/** @typedef {Record<string, string> & { _isLegacyAssert?: boolean }} ImportAttributes */
+/** @typedef {function(string): void} OnIdentString */
+/** @typedef {function(string, Identifier): void} OnIdent */
+/** @typedef {StatementPathItem[]} StatementPath */
+
+// 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> }} ImportDeclaration */
+/** @typedef {import("estree").ExportNamedDeclaration & { attributes?: Array<ImportAttribute> }} ExportNamedDeclaration */
+/** @typedef {import("estree").ExportAllDeclaration & { attributes?: Array<ImportAttribute> }} ExportAllDeclaration */
+/** @typedef {import("estree").ImportExpression & { options?: Expression | null }} ImportExpression */
+/** @typedef {ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration} ModuleDeclaration */
 
 /** @type {string[]} */
 const EMPTY_ARRAY = [];
@@ -107,9 +113,146 @@ const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
 const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
 const ALLOWED_MEMBER_TYPES_ALL = 0b11;
 
+const LEGACY_ASSERT_ATTRIBUTES = Symbol("assert");
+
+/**
+ * @param {any} Parser parser
+ * @returns {typeof AcornParser} extender acorn parser
+ */
+const importAssertions = Parser =>
+	/** @type {typeof AcornParser} */ (
+		/** @type {unknown} */ (
+			class extends Parser {
+				parseWithClause() {
+					const nodes = [];
+
+					const isAssertLegacy = this.value === "assert";
+
+					if (isAssertLegacy) {
+						if (!this.eat(tokTypes.name)) {
+							return nodes;
+						}
+					} else if (!this.eat(tokTypes._with)) {
+						return nodes;
+					}
+
+					this.expect(tokTypes.braceL);
+
+					const attributeKeys = {};
+					let first = true;
+
+					while (!this.eat(tokTypes.braceR)) {
+						if (!first) {
+							this.expect(tokTypes.comma);
+							if (this.afterTrailingComma(tokTypes.braceR)) {
+								break;
+							}
+						} else {
+							first = false;
+						}
+
+						const attr = this.parseImportAttribute();
+						const keyName =
+							attr.key.type === "Identifier" ? attr.key.name : attr.key.value;
+
+						if (Object.prototype.hasOwnProperty.call(attributeKeys, keyName)) {
+							this.raiseRecoverable(
+								attr.key.start,
+								`Duplicate attribute key '${keyName}'`
+							);
+						}
+
+						attributeKeys[keyName] = true;
+						nodes.push(attr);
+					}
+
+					if (isAssertLegacy) {
+						nodes[LEGACY_ASSERT_ATTRIBUTES] = true;
+					}
+
+					return nodes;
+				}
+			}
+		)
+	);
+
 // Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
+const parser = AcornParser.extend(importAssertions);
 
-const parser = AcornParser.extend(importAttributesOrAssertions);
+/** @typedef {Record<string, string> & { _isLegacyAssert?: boolean }} ImportAttributes */
+
+/**
+ * @param {ImportDeclaration | ExportNamedDeclaration | ExportAllDeclaration | ImportExpression} node node with assertions
+ * @returns {ImportAttributes | undefined} import attributes
+ */
+const getImportAttributes = node => {
+	if (node.type === "ImportExpression") {
+		if (
+			node.options &&
+			node.options.type === "ObjectExpression" &&
+			node.options.properties[0] &&
+			node.options.properties[0].type === "Property" &&
+			node.options.properties[0].key.type === "Identifier" &&
+			(node.options.properties[0].key.name === "with" ||
+				node.options.properties[0].key.name === "assert") &&
+			node.options.properties[0].value.type === "ObjectExpression" &&
+			node.options.properties[0].value.properties.length > 0
+		) {
+			const properties =
+				/** @type {Property[]} */
+				(node.options.properties[0].value.properties);
+			const result = /** @type {ImportAttributes} */ ({});
+			for (const property of properties) {
+				const key =
+					/** @type {string} */
+					(
+						property.key.type === "Identifier"
+							? property.key.name
+							: /** @type {Literal} */ (property.key).value
+					);
+				result[key] =
+					/** @type {string} */
+					(/** @type {Literal} */ (property.value).value);
+			}
+			const key =
+				node.options.properties[0].key.type === "Identifier"
+					? node.options.properties[0].key.name
+					: /** @type {Literal} */ (node.options.properties[0].key).value;
+
+			if (key === "assert") {
+				result._isLegacyAssert = true;
+			}
+
+			return result;
+		}
+
+		return;
+	}
+
+	if (node.attributes === undefined || node.attributes.length === 0) {
+		return;
+	}
+
+	const result = /** @type {ImportAttributes} */ ({});
+
+	for (const attribute of node.attributes) {
+		const key =
+			/** @type {string} */
+			(
+				attribute.key.type === "Identifier"
+					? attribute.key.name
+					: attribute.key.value
+			);
+
+		result[key] = /** @type {string} */ (attribute.value.value);
+	}
+
+	if (node.attributes[LEGACY_ASSERT_ATTRIBUTES]) {
+		result._isLegacyAssert = true;
+	}
+
+	return result;
+};
 
 class VariableInfo {
 	/**
@@ -228,12 +371,9 @@ const defaultParserOptions = {
 	sourceType: "module",
 	// https://github.com/tc39/proposal-hashbang
 	allowHashBang: true,
-	onComment: null
+	onComment: undefined
 };
 
-// regexp to match at least one "magic comment"
-const webpackCommentRegExp = new RegExp(/(^|\W)webpack[A-Z]{1,}[A-Za-z]{1,}:/);
-
 const EMPTY_COMMENT_OPTIONS = {
 	options: null,
 	errors: null
@@ -246,25 +386,25 @@ class JavascriptParser extends Parser {
 	constructor(sourceType = "auto") {
 		super();
 		this.hooks = Object.freeze({
-			/** @type {HookMap<SyncBailHook<[UnaryExpression], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[UnaryExpression], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[Expression | SpreadElement], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[Expression | SpreadElement | PrivateIdentifier], BasicEvaluatedExpression | null | undefined>>} */
 			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression | MetaProperty], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression | MetaProperty], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
-			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[Identifier | ThisExpression | MemberExpression], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateDefinedIdentifier: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[NewExpression], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[NewExpression], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateNewExpression: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[CallExpression], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateCallExpression: new HookMap(
 				() => new SyncBailHook(["expression"])
 			),
-			/** @type {HookMap<SyncBailHook<[CallExpression, BasicEvaluatedExpression], BasicEvaluatedExpression | undefined | null>>} */
+			/** @type {HookMap<SyncBailHook<[CallExpression, BasicEvaluatedExpression], BasicEvaluatedExpression | null | undefined>>} */
 			evaluateCallExpressionMember: new HookMap(
 				() => new SyncBailHook(["expression", "param"])
 			),
@@ -298,7 +438,7 @@ class JavascriptParser extends Parser {
 			label: new HookMap(() => new SyncBailHook(["statement"])),
 			/** @type {SyncBailHook<[ImportDeclaration, ImportSource], boolean | void>} */
 			import: new SyncBailHook(["statement", "source"]),
-			/** @type {SyncBailHook<[ImportDeclaration, ImportSource, string, string], boolean | void>} */
+			/** @type {SyncBailHook<[ImportDeclaration, ImportSource, string | null, string], boolean | void>} */
 			importSpecifier: new SyncBailHook([
 				"statement",
 				"source",
@@ -320,7 +460,7 @@ class JavascriptParser extends Parser {
 				"exportName",
 				"index"
 			]),
-			/** @type {SyncBailHook<[ExportNamedDeclaration | ExportAllDeclaration, ImportSource, string, string, number | undefined], boolean | void>} */
+			/** @type {SyncBailHook<[ExportNamedDeclaration | ExportAllDeclaration, ImportSource, string | null, string | null, number | undefined], boolean | void>} */
 			exportImportSpecifier: new SyncBailHook([
 				"statement",
 				"source",
@@ -435,17 +575,14 @@ class JavascriptParser extends Parser {
 		this.comments = undefined;
 		/** @type {Set<number> | undefined} */
 		this.semicolons = undefined;
-		/** @type {StatementPathItem[]} */
+		/** @type {StatementPath | undefined} */
 		this.statementPath = undefined;
 		/** @type {Statement | ModuleDeclaration | Expression | undefined} */
 		this.prevStatement = undefined;
 		/** @type {WeakMap<Expression, Set<DestructuringAssignmentProperty>> | undefined} */
 		this.destructuringAssignmentProperties = undefined;
 		this.currentTagData = undefined;
-		this.magicCommentContext = vm.createContext(undefined, {
-			name: "Webpack Magic Comment Parser",
-			codeGeneration: { strings: false, wasm: false }
-		});
+		this.magicCommentContext = createMagicCommentContext();
 		this._initializeEvaluating();
 	}
 
@@ -552,7 +689,7 @@ class JavascriptParser extends Parser {
 
 				const left = this.evaluateExpression(expr.left);
 				let returnRight = false;
-				/** @type {boolean|undefined} */
+				/** @type {boolean | undefined} */
 				let allowedRight;
 				if (expr.operator === "&&") {
 					const leftAsBool = left.asBool();
@@ -1105,7 +1242,7 @@ class JavascriptParser extends Parser {
 						case "MetaProperty": {
 							const res = this.callHooksForName(
 								this.hooks.evaluateTypeof,
-								getRootName(expr.argument),
+								/** @type {string} */ (getRootName(expr.argument)),
 								expr
 							);
 							if (res !== undefined) return res;
@@ -1211,7 +1348,7 @@ class JavascriptParser extends Parser {
 			}
 		});
 		/**
-		 * @param {string} exprType expression type name
+		 * @param {"Identifier" | "ThisExpression" | "MemberExpression"} exprType expression type name
 		 * @param {function(Expression | SpreadElement): GetInfoResult | undefined} getInfo get info
 		 * @returns {void}
 		 */
@@ -1221,9 +1358,10 @@ class JavascriptParser extends Parser {
 			/** @type {GetInfoResult | undefined} */
 			let cachedInfo;
 			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
-				const expression = /** @type {MemberExpression} */ (expr);
+				const expression =
+					/** @type {Identifier | ThisExpression | MemberExpression} */ (expr);
 
-				const info = getInfo(expr);
+				const info = getInfo(expression);
 				if (info !== undefined) {
 					return this.callHooksForInfoWithFallback(
 						this.hooks.evaluateIdentifier,
@@ -1245,7 +1383,11 @@ class JavascriptParser extends Parser {
 			this.hooks.evaluate
 				.for(exprType)
 				.tap({ name: "JavascriptParser", stage: 100 }, expr => {
-					const info = cachedExpression === expr ? cachedInfo : getInfo(expr);
+					const expression =
+						/** @type {Identifier | ThisExpression | MemberExpression} */
+						(expr);
+					const info =
+						cachedExpression === expression ? cachedInfo : getInfo(expression);
 					if (info !== undefined) {
 						return new BasicEvaluatedExpression()
 							.setIdentifier(
@@ -1255,7 +1397,7 @@ class JavascriptParser extends Parser {
 								info.getMembersOptionals,
 								info.getMemberRanges
 							)
-							.setRange(/** @type {Range} */ (expr.range));
+							.setRange(/** @type {Range} */ (expression.range));
 					}
 				});
 			this.hooks.finish.tap("JavascriptParser", () => {
@@ -1298,7 +1440,7 @@ class JavascriptParser extends Parser {
 
 			return this.callHooksForName(
 				this.hooks.evaluateIdentifier,
-				getRootName(expr),
+				/** @type {string} */ (getRootName(metaProperty)),
 				metaProperty
 			);
 		});
@@ -1711,7 +1853,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Expression} expr expression
+	 * @param {Expression | SpreadElement} expr expression
 	 * @returns {string | VariableInfoInterface | undefined} identifier
 	 */
 	getRenameIdentifier(expr) {
@@ -1807,9 +1949,12 @@ class JavascriptParser extends Parser {
 	 * @param {Statement | ModuleDeclaration} statement statement
 	 */
 	preWalkStatement(statement) {
-		this.statementPath.push(statement);
+		/** @type {StatementPath} */
+		(this.statementPath).push(statement);
 		if (this.hooks.preStatement.call(statement)) {
-			this.prevStatement = this.statementPath.pop();
+			this.prevStatement =
+				/** @type {StatementPath} */
+				(this.statementPath).pop();
 			return;
 		}
 		switch (statement.type) {
@@ -1853,16 +1998,21 @@ class JavascriptParser extends Parser {
 				this.preWalkWithStatement(statement);
 				break;
 		}
-		this.prevStatement = this.statementPath.pop();
+		this.prevStatement =
+			/** @type {StatementPath} */
+			(this.statementPath).pop();
 	}
 
 	/**
 	 * @param {Statement | ModuleDeclaration} statement statement
 	 */
 	blockPreWalkStatement(statement) {
-		this.statementPath.push(statement);
+		/** @type {StatementPath} */
+		(this.statementPath).push(statement);
 		if (this.hooks.blockPreStatement.call(statement)) {
-			this.prevStatement = this.statementPath.pop();
+			this.prevStatement =
+				/** @type {StatementPath} */
+				(this.statementPath).pop();
 			return;
 		}
 		switch (statement.type) {
@@ -1887,16 +2037,21 @@ class JavascriptParser extends Parser {
 			case "ExpressionStatement":
 				this.blockPreWalkExpressionStatement(statement);
 		}
-		this.prevStatement = this.statementPath.pop();
+		this.prevStatement =
+			/** @type {StatementPath} */
+			(this.statementPath).pop();
 	}
 
 	/**
 	 * @param {Statement | ModuleDeclaration} statement statement
 	 */
 	walkStatement(statement) {
-		this.statementPath.push(statement);
+		/** @type {StatementPath} */
+		(this.statementPath).push(statement);
 		if (this.hooks.statement.call(statement) !== undefined) {
-			this.prevStatement = this.statementPath.pop();
+			this.prevStatement =
+				/** @type {StatementPath} */
+				(this.statementPath).pop();
 			return;
 		}
 		switch (statement.type) {
@@ -1958,7 +2113,9 @@ class JavascriptParser extends Parser {
 				this.walkWithStatement(statement);
 				break;
 		}
-		this.prevStatement = this.statementPath.pop();
+		this.prevStatement =
+			/** @type {StatementPath} */
+			(this.statementPath).pop();
 	}
 
 	/**
@@ -2365,12 +2522,13 @@ class JavascriptParser extends Parser {
 						!this.hooks.importSpecifier.call(
 							statement,
 							source,
-							specifier.imported.name ||
-								// eslint-disable-next-line no-warning-comments
-								// @ts-ignore
-								// Old version of acorn used it
-								// TODO drop it in webpack@6
-								specifier.imported.value,
+							/** @type {Identifier} */
+							(specifier.imported).name ||
+								/** @type {string} */
+								(
+									/** @type {Literal} */
+									(specifier.imported).value
+								),
 							name
 						)
 					) {
@@ -2446,25 +2604,28 @@ class JavascriptParser extends Parser {
 				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 =
-							specifier.exported.name ||
-							// eslint-disable-next-line no-warning-comments
-							// @ts-ignore
-							// Old version of acorn used it
-							// TODO drop it in webpack@6
-							specifier.exported.value;
+							/** @type {Identifier} */
+							(specifier.exported).name ||
+							/** @type {string} */
+							(/** @type {Literal} */ (specifier.exported).value);
 						if (source) {
 							this.hooks.exportImportSpecifier.call(
 								statement,
 								source,
-								specifier.local.name,
+								localName,
 								name,
 								specifierIndex
 							);
 						} else {
 							this.hooks.exportSpecifier.call(
 								statement,
-								specifier.local.name,
+								localName,
 								name,
 								specifierIndex
 							);
@@ -2567,7 +2728,12 @@ class JavascriptParser extends Parser {
 	 */
 	blockPreWalkExportAllDeclaration(statement) {
 		const source = /** @type {ImportSource} */ (statement.source.value);
-		const name = statement.exported ? statement.exported.name : null;
+		const name = statement.exported
+			? /** @type {Identifier} */
+				(statement.exported).name ||
+				/** @type {string} */
+				(/** @type {Literal} */ (statement.exported).value)
+			: null;
 		this.hooks.exportImport.call(statement, source);
 		this.hooks.exportImportSpecifier.call(statement, source, null, name, 0);
 	}
@@ -2640,7 +2806,7 @@ class JavascriptParser extends Parser {
 					shorthand: this.scope.inShorthand
 				});
 			} else {
-				const id = this.evaluateExpression(/** @type {TODO} */ (key));
+				const id = this.evaluateExpression(key);
 				const str = id.asString();
 				if (str) {
 					props.add({
@@ -3089,21 +3255,32 @@ class JavascriptParser extends Parser {
 		if (!expression.expressions) return;
 		// We treat sequence expressions like statements when they are one statement level
 		// This has some benefits for optimizations that only work on statement level
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		const currentStatement =
+			/** @type {StatementPath} */
+			(this.statementPath)[
+				/** @type {StatementPath} */
+				(this.statementPath).length - 1
+			];
 		if (
 			currentStatement === expression ||
 			(currentStatement.type === "ExpressionStatement" &&
 				currentStatement.expression === expression)
 		) {
-			const old = /** @type {StatementPathItem} */ (this.statementPath.pop());
+			const old =
+				/** @type {StatementPathItem} */
+				(/** @type {StatementPath} */ (this.statementPath).pop());
 			const prev = this.prevStatement;
 			for (const expr of expression.expressions) {
-				this.statementPath.push(expr);
+				/** @type {StatementPath} */
+				(this.statementPath).push(expr);
 				this.walkExpression(expr);
-				this.prevStatement = this.statementPath.pop();
+				this.prevStatement =
+					/** @type {StatementPath} */
+					(this.statementPath).pop();
 			}
 			this.prevStatement = prev;
-			this.statementPath.push(old);
+			/** @type {StatementPath} */
+			(this.statementPath).push(old);
 		} else {
 			this.walkExpressions(expression.expressions);
 		}
@@ -3339,17 +3516,21 @@ class JavascriptParser extends Parser {
 		 * @returns {string | VariableInfoInterface | undefined} var info
 		 */
 		const getVarInfo = argOrThis => {
-			const renameIdentifier = this.getRenameIdentifier(
-				/** @type {Expression} */ (argOrThis)
-			);
+			const renameIdentifier = this.getRenameIdentifier(argOrThis);
 			if (
 				renameIdentifier &&
 				this.callHooksForInfo(
 					this.hooks.canRename,
 					renameIdentifier,
-					argOrThis
+					/** @type {Expression} */
+					(argOrThis)
 				) &&
-				!this.callHooksForInfo(this.hooks.rename, renameIdentifier, argOrThis)
+				!this.callHooksForInfo(
+					this.hooks.rename,
+					renameIdentifier,
+					/** @type {Expression} */
+					(argOrThis)
+				)
 			) {
 				return typeof renameIdentifier === "string"
 					? /** @type {string} */ (this.getVariableInfo(renameIdentifier))
@@ -3412,6 +3593,10 @@ class JavascriptParser extends Parser {
 	 * @param {CallExpression} expression expression
 	 */
 	walkCallExpression(expression) {
+		/**
+		 * @param {FunctionExpression | ArrowFunctionExpression} fn function
+		 * @returns {boolean} true when simple function
+		 */
 		const isSimpleFunction = fn =>
 			fn.params.every(p => p.type === "Identifier");
 		if (
@@ -3426,7 +3611,10 @@ class JavascriptParser extends Parser {
 				// @ts-ignore
 				expression.callee.property.name === "bind") &&
 			expression.arguments.length > 0 &&
-			isSimpleFunction(expression.callee.object)
+			isSimpleFunction(
+				/** @type {FunctionExpression | ArrowFunctionExpression} */
+				(expression.callee.object)
+			)
 		) {
 			// (function(…) { }.call/bind(?, …))
 			this._walkIIFE(
@@ -3437,7 +3625,10 @@ class JavascriptParser extends Parser {
 			);
 		} else if (
 			expression.callee.type.endsWith("FunctionExpression") &&
-			isSimpleFunction(expression.callee)
+			isSimpleFunction(
+				/** @type {FunctionExpression | ArrowFunctionExpression} */
+				(expression.callee)
+			)
 		) {
 			// (function(…) { }(…))
 			this._walkIIFE(
@@ -3471,18 +3662,22 @@ class JavascriptParser extends Parser {
 			if (callee.isIdentifier()) {
 				const result1 = this.callHooksForInfo(
 					this.hooks.callMemberChain,
-					callee.rootInfo,
+					/** @type {NonNullable<BasicEvaluatedExpression["rootInfo"]>} */
+					(callee.rootInfo),
 					expression,
-					callee.getMembers(),
+					/** @type {NonNullable<BasicEvaluatedExpression["getMembers"]>} */
+					(callee.getMembers)(),
 					callee.getMembersOptionals
 						? callee.getMembersOptionals()
-						: callee.getMembers().map(() => false),
+						: /** @type {NonNullable<BasicEvaluatedExpression["getMembers"]>} */
+							(callee.getMembers)().map(() => false),
 					callee.getMemberRanges ? callee.getMemberRanges() : []
 				);
 				if (result1 === true) return;
 				const result2 = this.callHooksForInfo(
 					this.hooks.call,
-					callee.identifier,
+					/** @type {NonNullable<BasicEvaluatedExpression["identifier"]>} */
+					(callee.identifier),
 					expression
 				);
 				if (result2 === true) return;
@@ -3633,7 +3828,7 @@ class JavascriptParser extends Parser {
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {TODO} expr expression
+	 * @param {Expression | Super} expr expression
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
@@ -3651,7 +3846,7 @@ class JavascriptParser extends Parser {
 	 * @template T
 	 * @template R
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
-	 * @param {MemberExpression} expr expression info
+	 * @param {Expression | Super} expr expression info
 	 * @param {(function(string, string | ScopeInfo | VariableInfo, function(): string[]): any) | undefined} fallback callback when variable in not handled by hooks
 	 * @param {(function(string): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
@@ -3723,7 +3918,7 @@ class JavascriptParser extends Parser {
 	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
 	 * @param {ExportedVariableInfo} info variable info
 	 * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
-	 * @param {(function(): any) | undefined} defined callback when variable is defined
+	 * @param {(function(string=): any) | undefined} defined callback when variable is defined
 	 * @param {AsArray<T>} args args for the hook
 	 * @returns {R | undefined} result of hook
 	 */
@@ -3763,7 +3958,7 @@ class JavascriptParser extends Parser {
 			if (result !== undefined) return result;
 		}
 		if (fallback !== undefined) {
-			return fallback(name);
+			return fallback(/** @type {string} */ (name));
 		}
 	}
 
@@ -3807,7 +4002,7 @@ class JavascriptParser extends Parser {
 
 		this.undefineVariable("this");
 
-		this.enterPatterns(params, (ident, pattern) => {
+		this.enterPatterns(params, ident => {
 			this.defineVariable(ident);
 		});
 
@@ -3818,7 +4013,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {boolean} hasThis true, when this is defined
-	 * @param {any} params scope params
+	 * @param {Identifier[]} params scope params
 	 * @param {function(): void} fn inner function
 	 * @returns {void}
 	 */
@@ -3838,7 +4033,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, (ident, pattern) => {
+		this.enterPatterns(params, ident => {
 			this.defineVariable(ident);
 		});
 
@@ -3849,7 +4044,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {boolean} hasThis true, when this is defined
-	 * @param {any} params scope params
+	 * @param {(Pattern | string)[]} params scope params
 	 * @param {function(): void} fn inner function
 	 * @returns {void}
 	 */
@@ -3869,7 +4064,7 @@ class JavascriptParser extends Parser {
 			this.undefineVariable("this");
 		}
 
-		this.enterPatterns(params, (ident, pattern) => {
+		this.enterPatterns(params, ident => {
 			this.defineVariable(ident);
 		});
 
@@ -3927,7 +4122,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {(string | Pattern | Property)[]} patterns patterns
-	 * @param {OnIdent} onIdent on ident callback
+	 * @param {OnIdentString} onIdent on ident callback
 	 */
 	enterPatterns(patterns, onIdent) {
 		for (const pattern of patterns) {
@@ -3967,7 +4162,7 @@ class JavascriptParser extends Parser {
 					this.enterIdentifier(pattern.value, onIdent);
 					this.scope.inShorthand = false;
 				} else {
-					this.enterPattern(/** @type {Identifier} */ (pattern.value), onIdent);
+					this.enterPattern(/** @type {Pattern} */ (pattern.value), onIdent);
 				}
 				break;
 		}
@@ -4033,7 +4228,7 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {Expression | SpreadElement} expression expression node
+	 * @param {Expression | SpreadElement | PrivateIdentifier} expression expression node
 	 * @returns {BasicEvaluatedExpression} evaluation result
 	 */
 	evaluateExpression(expression) {
@@ -4064,7 +4259,7 @@ class JavascriptParser extends Parser {
 			case "BinaryExpression":
 				if (expression.operator === "+") {
 					return (
-						this.parseString(expression.left) +
+						this.parseString(/** @type {Expression} */ (expression.left)) +
 						this.parseString(expression.right)
 					);
 				}
@@ -4079,13 +4274,16 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Expression} expression expression
-	 * @returns {TODO} result
+	 * @returns {{ range?: Range, value: string, code: boolean, conditional: TODO }} result
 	 */
 	parseCalculatedString(expression) {
 		switch (expression.type) {
 			case "BinaryExpression":
 				if (expression.operator === "+") {
-					const left = this.parseCalculatedString(expression.left);
+					const left = this.parseCalculatedString(
+						/** @type {Expression} */
+						(expression.left)
+					);
 					const right = this.parseCalculatedString(expression.right);
 					if (left.code) {
 						return {
@@ -4097,8 +4295,11 @@ class JavascriptParser extends Parser {
 					} else if (right.code) {
 						return {
 							range: [
-								left.range[0],
-								right.range ? right.range[1] : left.range[1]
+								/** @type {Range} */
+								(left.range)[0],
+								right.range
+									? right.range[1]
+									: /** @type {Range} */ (left.range)[1]
 							],
 							value: left.value + right.value,
 							code: true,
@@ -4106,7 +4307,12 @@ class JavascriptParser extends Parser {
 						};
 					}
 					return {
-						range: [left.range[0], right.range[1]],
+						range: [
+							/** @type {Range} */
+							(left.range)[0],
+							/** @type {Range} */
+							(right.range)[1]
+						],
 						value: left.value + right.value,
 						code: false,
 						conditional: false
@@ -4161,6 +4367,7 @@ class JavascriptParser extends Parser {
 	 */
 	parse(source, state) {
 		let ast;
+		/** @type {import("acorn").Comment[]} */
 		let comments;
 		const semicolons = new Set();
 		if (source === null) {
@@ -4398,20 +4605,27 @@ class JavascriptParser extends Parser {
 	 * @returns {boolean} true when a semicolon has been inserted before this position, false if not
 	 */
 	isAsiPosition(pos) {
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		const currentStatement =
+			/** @type {StatementPath} */
+			(this.statementPath)[
+				/** @type {StatementPath} */
+				(this.statementPath).length - 1
+			];
 		if (currentStatement === undefined) throw new Error("Not in statement");
+		const range = /** @type {Range} */ (currentStatement.range);
+
 		return (
 			// Either asking directly for the end position of the current statement
-			(currentStatement.range[1] === pos &&
+			(range[1] === pos &&
 				/** @type {Set<number>} */ (this.semicolons).has(pos)) ||
 			// Or asking for the start position of the current statement,
 			// here we have to check multiple things
-			(currentStatement.range[0] === pos &&
+			(range[0] === pos &&
 				// is there a previous statement which might be relevant?
 				this.prevStatement !== undefined &&
 				// is the end position of the previous statement an ASI position?
 				/** @type {Set<number>} */ (this.semicolons).has(
-					this.prevStatement.range[1]
+					/** @type {Range} */ (this.prevStatement.range)[1]
 				))
 		);
 	}
@@ -4437,7 +4651,12 @@ class JavascriptParser extends Parser {
 	 * @returns {boolean} true, when the expression is a statement level expression
 	 */
 	isStatementLevelExpression(expr) {
-		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		const currentStatement =
+			/** @type {StatementPath} */
+			(this.statementPath)[
+				/** @type {StatementPath} */
+				(this.statementPath).length - 1
+			];
 		return (
 			expr === currentStatement ||
 			(currentStatement.type === "ExpressionStatement" &&
@@ -4447,7 +4666,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name name
-	 * @param {TODO} tag tag info
+	 * @param {symbol} tag tag info
 	 * @returns {TODO} tag data
 	 */
 	getTagData(name, tag) {
@@ -4463,7 +4682,7 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {string} name name
-	 * @param {TODO} tag tag info
+	 * @param {symbol} tag tag info
 	 * @param {TODO=} data data
 	 */
 	tagVariable(name, tag, data) {
@@ -4565,15 +4784,16 @@ class JavascriptParser extends Parser {
 
 	/**
 	 * @param {Range} range range of the comment
-	 * @returns {TODO} TODO
+	 * @returns {{ options: Record<string, any> | null, errors: (Error & { comment: Comment })[] | null }} result
 	 */
 	parseCommentOptions(range) {
 		const comments = this.getComments(range);
 		if (comments.length === 0) {
 			return EMPTY_COMMENT_OPTIONS;
 		}
+		/** @type {Record<string, EXPECTED_ANY> } */
 		const options = {};
-		/** @type {unknown[]} */
+		/** @type {(Error & { comment: Comment })[]} */
 		const errors = [];
 		for (const comment of comments) {
 			const { value } = comment;
@@ -4595,10 +4815,10 @@ class JavascriptParser extends Parser {
 						options[key] = val;
 					}
 				} catch (err) {
-					const newErr = new Error(String(err.message));
-					newErr.stack = String(err.stack);
+					const newErr = new Error(String(/** @type {Error} */ (err).message));
+					newErr.stack = String(/** @type {Error} */ (err).stack);
 					Object.assign(newErr, { comment });
-					errors.push(newErr);
+					errors.push(/** @type {(Error & { comment: Comment })} */ (newErr));
 				}
 			}
 		}
@@ -4606,11 +4826,11 @@ class JavascriptParser extends Parser {
 	}
 
 	/**
-	 * @param {MemberExpression} expression a member expression
+	 * @param {Expression | Super} expression a member expression
 	 * @returns {{ members: string[], object: Expression | Super, membersOptionals: boolean[], memberRanges: Range[] }} member names (reverse order) and remaining object
 	 */
 	extractMemberExpressionChain(expression) {
-		/** @type {AnyNode} */
+		/** @type {Node} */
 		let expr = expression;
 		const members = [];
 		const membersOptionals = [];
@@ -4659,7 +4879,7 @@ class JavascriptParser extends Parser {
 	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[], getMembersOptionals: () => boolean[], getMemberRanges: () => Range[]}} ExpressionExpressionInfo */
 
 	/**
-	 * @param {MemberExpression} expression a member expression
+	 * @param {Expression | Super} expression a member expression
 	 * @param {number} allowedTypes which types should be returned, presented in bit mask
 	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
 	 */
@@ -4741,12 +4961,12 @@ class JavascriptParser extends Parser {
 			sourceType: type === "auto" ? "module" : type
 		};
 
-		/** @type {AnyNode | undefined} */
+		/** @type {import("acorn").Program | undefined} */
 		let ast;
 		let error;
 		let threw = false;
 		try {
-			ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
+			ast = parser.parse(code, parserOptions);
 		} catch (err) {
 			error = err;
 			threw = true;
@@ -4761,7 +4981,7 @@ class JavascriptParser extends Parser {
 				parserOptions.onComment.length = 0;
 			}
 			try {
-				ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
+				ast = parser.parse(code, parserOptions);
 				threw = false;
 			} catch (_err) {
 				// we use the error from first parse try
@@ -4783,3 +5003,4 @@ module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
 	ALLOWED_MEMBER_TYPES_EXPRESSION;
 module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
 	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;
+module.exports.getImportAttributes = getImportAttributes;