mathjs 10.4.1 → 10.4.2

package/examples/node_modules/webpack/lib/javascript/JavascriptParser.js

@@ -0,0 +1,3776 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const { Parser: AcornParser } = require("acorn");
+const { importAssertions } = require("acorn-import-assertions");
+const { SyncBailHook, HookMap } = require("tapable");
+const vm = require("vm");
+const Parser = require("../Parser");
+const StackedMap = require("../util/StackedMap");
+const binarySearchBounds = require("../util/binarySearchBounds");
+const memoize = require("../util/memoize");
+const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
+
+/** @typedef {import("acorn").Options} AcornOptions */
+/** @typedef {import("estree").ArrayExpression} ArrayExpressionNode */
+/** @typedef {import("estree").BinaryExpression} BinaryExpressionNode */
+/** @typedef {import("estree").BlockStatement} BlockStatementNode */
+/** @typedef {import("estree").SequenceExpression} SequenceExpressionNode */
+/** @typedef {import("estree").CallExpression} CallExpressionNode */
+/** @typedef {import("estree").ClassDeclaration} ClassDeclarationNode */
+/** @typedef {import("estree").ClassExpression} ClassExpressionNode */
+/** @typedef {import("estree").Comment} CommentNode */
+/** @typedef {import("estree").ConditionalExpression} ConditionalExpressionNode */
+/** @typedef {import("estree").Declaration} DeclarationNode */
+/** @typedef {import("estree").PrivateIdentifier} PrivateIdentifierNode */
+/** @typedef {import("estree").PropertyDefinition} PropertyDefinitionNode */
+/** @typedef {import("estree").Expression} ExpressionNode */
+/** @typedef {import("estree").Identifier} IdentifierNode */
+/** @typedef {import("estree").IfStatement} IfStatementNode */
+/** @typedef {import("estree").LabeledStatement} LabeledStatementNode */
+/** @typedef {import("estree").Literal} LiteralNode */
+/** @typedef {import("estree").LogicalExpression} LogicalExpressionNode */
+/** @typedef {import("estree").ChainExpression} ChainExpressionNode */
+/** @typedef {import("estree").MemberExpression} MemberExpressionNode */
+/** @typedef {import("estree").MetaProperty} MetaPropertyNode */
+/** @typedef {import("estree").MethodDefinition} MethodDefinitionNode */
+/** @typedef {import("estree").ModuleDeclaration} ModuleDeclarationNode */
+/** @typedef {import("estree").NewExpression} NewExpressionNode */
+/** @typedef {import("estree").Node} AnyNode */
+/** @typedef {import("estree").Program} ProgramNode */
+/** @typedef {import("estree").Statement} StatementNode */
+/** @typedef {import("estree").ImportDeclaration} ImportDeclarationNode */
+/** @typedef {import("estree").ExportNamedDeclaration} ExportNamedDeclarationNode */
+/** @typedef {import("estree").ExportDefaultDeclaration} ExportDefaultDeclarationNode */
+/** @typedef {import("estree").ExportAllDeclaration} ExportAllDeclarationNode */
+/** @typedef {import("estree").Super} SuperNode */
+/** @typedef {import("estree").TaggedTemplateExpression} TaggedTemplateExpressionNode */
+/** @typedef {import("estree").TemplateLiteral} TemplateLiteralNode */
+/** @typedef {import("estree").ThisExpression} ThisExpressionNode */
+/** @typedef {import("estree").UnaryExpression} UnaryExpressionNode */
+/** @typedef {import("estree").VariableDeclarator} VariableDeclaratorNode */
+/** @template T @typedef {import("tapable").AsArray<T>} AsArray<T> */
+/** @typedef {import("../Parser").ParserState} ParserState */
+/** @typedef {import("../Parser").PreparsedAst} PreparsedAst */
+/** @typedef {{declaredScope: ScopeInfo, freeName: string | true, tagInfo: TagInfo | undefined}} VariableInfoInterface */
+/** @typedef {{ name: string | VariableInfo, rootInfo: string | VariableInfo, getMembers: () => string[] }} GetInfoResult */
+
+const EMPTY_ARRAY = [];
+const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 0b01;
+const ALLOWED_MEMBER_TYPES_EXPRESSION = 0b10;
+const ALLOWED_MEMBER_TYPES_ALL = 0b11;
+
+// Syntax: https://developer.mozilla.org/en/SpiderMonkey/Parser_API
+
+const parser = AcornParser.extend(importAssertions);
+
+class VariableInfo {
+	/**
+	 * @param {ScopeInfo} declaredScope scope in which the variable is declared
+	 * @param {string | true} freeName which free name the variable aliases, or true when none
+	 * @param {TagInfo | undefined} tagInfo info about tags
+	 */
+	constructor(declaredScope, freeName, tagInfo) {
+		this.declaredScope = declaredScope;
+		this.freeName = freeName;
+		this.tagInfo = tagInfo;
+	}
+}
+
+/** @typedef {string | ScopeInfo | VariableInfo} ExportedVariableInfo */
+/** @typedef {LiteralNode | string | null | undefined} ImportSource */
+/** @typedef {Omit<AcornOptions, "sourceType" | "ecmaVersion"> & { sourceType: "module" | "script" | "auto", ecmaVersion?: AcornOptions["ecmaVersion"] }} ParseOptions */
+
+/**
+ * @typedef {Object} TagInfo
+ * @property {any} tag
+ * @property {any} data
+ * @property {TagInfo | undefined} next
+ */
+
+/**
+ * @typedef {Object} ScopeInfo
+ * @property {StackedMap<string, VariableInfo | ScopeInfo>} definitions
+ * @property {boolean | "arrow"} topLevelScope
+ * @property {boolean} inShorthand
+ * @property {boolean} isStrict
+ * @property {boolean} isAsmJs
+ * @property {boolean} inTry
+ */
+
+const joinRanges = (startRange, endRange) => {
+	if (!endRange) return startRange;
+	if (!startRange) return endRange;
+	return [startRange[0], endRange[1]];
+};
+
+const objectAndMembersToName = (object, membersReversed) => {
+	let name = object;
+	for (let i = membersReversed.length - 1; i >= 0; i--) {
+		name = name + "." + membersReversed[i];
+	}
+	return name;
+};
+
+const getRootName = expression => {
+	switch (expression.type) {
+		case "Identifier":
+			return expression.name;
+		case "ThisExpression":
+			return "this";
+		case "MetaProperty":
+			return `${expression.meta.name}.${expression.property.name}`;
+		default:
+			return undefined;
+	}
+};
+
+/** @type {AcornOptions} */
+const defaultParserOptions = {
+	ranges: true,
+	locations: true,
+	ecmaVersion: "latest",
+	sourceType: "module",
+	// https://github.com/tc39/proposal-hashbang
+	allowHashBang: true,
+	onComment: null
+};
+
+// 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
+};
+
+class JavascriptParser extends Parser {
+	/**
+	 * @param {"module" | "script" | "auto"} sourceType default source type
+	 */
+	constructor(sourceType = "auto") {
+		super();
+		this.hooks = Object.freeze({
+			/** @type {HookMap<SyncBailHook<[UnaryExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateTypeof: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluate: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode | MetaPropertyNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateIdentifier: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode | ThisExpressionNode | MemberExpressionNode], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateDefinedIdentifier: new HookMap(
+				() => new SyncBailHook(["expression"])
+			),
+			/** @type {HookMap<SyncBailHook<[CallExpressionNode, BasicEvaluatedExpression | undefined], BasicEvaluatedExpression | undefined | null>>} */
+			evaluateCallExpressionMember: new HookMap(
+				() => new SyncBailHook(["expression", "param"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode | DeclarationNode | PrivateIdentifierNode, number], boolean | void>>} */
+			isPure: new HookMap(
+				() => new SyncBailHook(["expression", "commentsStartPosition"])
+			),
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			preStatement: new SyncBailHook(["statement"]),
+
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			blockPreStatement: new SyncBailHook(["declaration"]),
+			/** @type {SyncBailHook<[StatementNode | ModuleDeclarationNode], boolean | void>} */
+			statement: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[IfStatementNode], boolean | void>} */
+			statementIf: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[ExpressionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classExtendsExpression: new SyncBailHook([
+				"expression",
+				"classDefinition"
+			]),
+			/** @type {SyncBailHook<[MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classBodyElement: new SyncBailHook(["element", "classDefinition"]),
+			/** @type {SyncBailHook<[ExpressionNode, MethodDefinitionNode | PropertyDefinitionNode, ClassExpressionNode | ClassDeclarationNode], boolean | void>} */
+			classBodyValue: new SyncBailHook([
+				"expression",
+				"element",
+				"classDefinition"
+			]),
+			/** @type {HookMap<SyncBailHook<[LabeledStatementNode], boolean | void>>} */
+			label: new HookMap(() => new SyncBailHook(["statement"])),
+			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource], boolean | void>} */
+			import: new SyncBailHook(["statement", "source"]),
+			/** @type {SyncBailHook<[ImportDeclarationNode, ImportSource, string, string], boolean | void>} */
+			importSpecifier: new SyncBailHook([
+				"statement",
+				"source",
+				"exportName",
+				"identifierName"
+			]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode], boolean | void>} */
+			export: new SyncBailHook(["statement"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource], boolean | void>} */
+			exportImport: new SyncBailHook(["statement", "source"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, DeclarationNode], boolean | void>} */
+			exportDeclaration: new SyncBailHook(["statement", "declaration"]),
+			/** @type {SyncBailHook<[ExportDefaultDeclarationNode, DeclarationNode], boolean | void>} */
+			exportExpression: new SyncBailHook(["statement", "declaration"]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, string, string, number | undefined], boolean | void>} */
+			exportSpecifier: new SyncBailHook([
+				"statement",
+				"identifierName",
+				"exportName",
+				"index"
+			]),
+			/** @type {SyncBailHook<[ExportNamedDeclarationNode | ExportAllDeclarationNode, ImportSource, string, string, number | undefined], boolean | void>} */
+			exportImportSpecifier: new SyncBailHook([
+				"statement",
+				"source",
+				"identifierName",
+				"exportName",
+				"index"
+			]),
+			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
+			preDeclarator: new SyncBailHook(["declarator", "statement"]),
+			/** @type {SyncBailHook<[VariableDeclaratorNode, StatementNode], boolean | void>} */
+			declarator: new SyncBailHook(["declarator", "statement"]),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclaration: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationLet: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationConst: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[DeclarationNode], boolean | void>>} */
+			varDeclarationVar: new HookMap(() => new SyncBailHook(["declaration"])),
+			/** @type {HookMap<SyncBailHook<[IdentifierNode], boolean | void>>} */
+			pattern: new HookMap(() => new SyncBailHook(["pattern"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			canRename: new HookMap(() => new SyncBailHook(["initExpression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			rename: new HookMap(() => new SyncBailHook(["initExpression"])),
+			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression], boolean | void>>} */
+			assign: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[import("estree").AssignmentExpression, string[]], boolean | void>>} */
+			assignMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			typeof: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			importCall: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			topLevelAwait: new SyncBailHook(["expression"]),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			call: new HookMap(() => new SyncBailHook(["expression"])),
+			/** Something like "a.b()" */
+			/** @type {HookMap<SyncBailHook<[CallExpressionNode, string[]], boolean | void>>} */
+			callMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** Something like "a.b().c.d" */
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			memberChainOfCallMemberChain: new HookMap(
+				() =>
+					new SyncBailHook([
+						"expression",
+						"calleeMembers",
+						"callExpression",
+						"members"
+					])
+			),
+			/** Something like "a.b().c.d()"" */
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[], CallExpressionNode, string[]], boolean | void>>} */
+			callMemberChainOfCallMemberChain: new HookMap(
+				() =>
+					new SyncBailHook([
+						"expression",
+						"calleeMembers",
+						"innerCallExpression",
+						"members"
+					])
+			),
+			/** @type {SyncBailHook<[ChainExpressionNode], boolean | void>} */
+			optionalChaining: new SyncBailHook(["optionalChaining"]),
+			/** @type {HookMap<SyncBailHook<[NewExpressionNode], boolean | void>>} */
+			new: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode], boolean | void>>} */
+			expression: new HookMap(() => new SyncBailHook(["expression"])),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			expressionMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {HookMap<SyncBailHook<[ExpressionNode, string[]], boolean | void>>} */
+			unhandledExpressionMemberChain: new HookMap(
+				() => new SyncBailHook(["expression", "members"])
+			),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			expressionConditionalOperator: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ExpressionNode], boolean | void>} */
+			expressionLogicalOperator: new SyncBailHook(["expression"]),
+			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
+			program: new SyncBailHook(["ast", "comments"]),
+			/** @type {SyncBailHook<[ProgramNode, CommentNode[]], boolean | void>} */
+			finish: new SyncBailHook(["ast", "comments"])
+		});
+		this.sourceType = sourceType;
+		/** @type {ScopeInfo} */
+		this.scope = undefined;
+		/** @type {ParserState} */
+		this.state = undefined;
+		this.comments = undefined;
+		this.semicolons = undefined;
+		/** @type {(StatementNode|ExpressionNode)[]} */
+		this.statementPath = undefined;
+		this.prevStatement = undefined;
+		this.currentTagData = undefined;
+		this._initializeEvaluating();
+	}
+
+	_initializeEvaluating() {
+		this.hooks.evaluate.for("Literal").tap("JavascriptParser", _expr => {
+			const expr = /** @type {LiteralNode} */ (_expr);
+
+			switch (typeof expr.value) {
+				case "number":
+					return new BasicEvaluatedExpression()
+						.setNumber(expr.value)
+						.setRange(expr.range);
+				case "bigint":
+					return new BasicEvaluatedExpression()
+						.setBigInt(expr.value)
+						.setRange(expr.range);
+				case "string":
+					return new BasicEvaluatedExpression()
+						.setString(expr.value)
+						.setRange(expr.range);
+				case "boolean":
+					return new BasicEvaluatedExpression()
+						.setBoolean(expr.value)
+						.setRange(expr.range);
+			}
+			if (expr.value === null) {
+				return new BasicEvaluatedExpression().setNull().setRange(expr.range);
+			}
+			if (expr.value instanceof RegExp) {
+				return new BasicEvaluatedExpression()
+					.setRegExp(expr.value)
+					.setRange(expr.range);
+			}
+		});
+		this.hooks.evaluate.for("NewExpression").tap("JavascriptParser", _expr => {
+			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const callee = expr.callee;
+			if (
+				callee.type !== "Identifier" ||
+				callee.name !== "RegExp" ||
+				expr.arguments.length > 2 ||
+				this.getVariableInfo("RegExp") !== "RegExp"
+			)
+				return;
+
+			let regExp, flags;
+			const arg1 = expr.arguments[0];
+
+			if (arg1) {
+				if (arg1.type === "SpreadElement") return;
+
+				const evaluatedRegExp = this.evaluateExpression(arg1);
+
+				if (!evaluatedRegExp) return;
+
+				regExp = evaluatedRegExp.asString();
+
+				if (!regExp) return;
+			} else {
+				return new BasicEvaluatedExpression()
+					.setRegExp(new RegExp(""))
+					.setRange(expr.range);
+			}
+
+			const arg2 = expr.arguments[1];
+
+			if (arg2) {
+				if (arg2.type === "SpreadElement") return;
+
+				const evaluatedFlags = this.evaluateExpression(arg2);
+
+				if (!evaluatedFlags) return;
+
+				if (!evaluatedFlags.isUndefined()) {
+					flags = evaluatedFlags.asString();
+
+					if (
+						flags === undefined ||
+						!BasicEvaluatedExpression.isValidRegExpFlags(flags)
+					)
+						return;
+				}
+			}
+
+			return new BasicEvaluatedExpression()
+				.setRegExp(flags ? new RegExp(regExp, flags) : new RegExp(regExp))
+				.setRange(expr.range);
+		});
+		this.hooks.evaluate
+			.for("LogicalExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {LogicalExpressionNode} */ (_expr);
+
+				const left = this.evaluateExpression(expr.left);
+				if (!left) return;
+				let returnRight = false;
+				/** @type {boolean|undefined} */
+				let allowedRight;
+				if (expr.operator === "&&") {
+					const leftAsBool = left.asBool();
+					if (leftAsBool === false) return left.setRange(expr.range);
+					returnRight = leftAsBool === true;
+					allowedRight = false;
+				} else if (expr.operator === "||") {
+					const leftAsBool = left.asBool();
+					if (leftAsBool === true) return left.setRange(expr.range);
+					returnRight = leftAsBool === false;
+					allowedRight = true;
+				} else if (expr.operator === "??") {
+					const leftAsNullish = left.asNullish();
+					if (leftAsNullish === false) return left.setRange(expr.range);
+					if (leftAsNullish !== true) return;
+					returnRight = true;
+				} else return;
+				const right = this.evaluateExpression(expr.right);
+				if (!right) return;
+				if (returnRight) {
+					if (left.couldHaveSideEffects()) right.setSideEffects();
+					return right.setRange(expr.range);
+				}
+
+				const asBool = right.asBool();
+
+				if (allowedRight === true && asBool === true) {
+					return new BasicEvaluatedExpression()
+						.setRange(expr.range)
+						.setTruthy();
+				} else if (allowedRight === false && asBool === false) {
+					return new BasicEvaluatedExpression().setRange(expr.range).setFalsy();
+				}
+			});
+
+		const valueAsExpression = (value, expr, sideEffects) => {
+			switch (typeof value) {
+				case "boolean":
+					return new BasicEvaluatedExpression()
+						.setBoolean(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "number":
+					return new BasicEvaluatedExpression()
+						.setNumber(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "bigint":
+					return new BasicEvaluatedExpression()
+						.setBigInt(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+				case "string":
+					return new BasicEvaluatedExpression()
+						.setString(value)
+						.setSideEffects(sideEffects)
+						.setRange(expr.range);
+			}
+		};
+
+		this.hooks.evaluate
+			.for("BinaryExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {BinaryExpressionNode} */ (_expr);
+
+				const handleConstOperation = fn => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left || !left.isCompileTimeValue()) return;
+
+					const right = this.evaluateExpression(expr.right);
+					if (!right || !right.isCompileTimeValue()) return;
+
+					const result = fn(
+						left.asCompileTimeValue(),
+						right.asCompileTimeValue()
+					);
+					return valueAsExpression(
+						result,
+						expr,
+						left.couldHaveSideEffects() || right.couldHaveSideEffects()
+					);
+				};
+
+				const isAlwaysDifferent = (a, b) =>
+					(a === true && b === false) || (a === false && b === true);
+
+				const handleTemplateStringCompare = (left, right, res, eql) => {
+					const getPrefix = parts => {
+						let value = "";
+						for (const p of parts) {
+							const v = p.asString();
+							if (v !== undefined) value += v;
+							else break;
+						}
+						return value;
+					};
+					const getSuffix = parts => {
+						let value = "";
+						for (let i = parts.length - 1; i >= 0; i--) {
+							const v = parts[i].asString();
+							if (v !== undefined) value = v + value;
+							else break;
+						}
+						return value;
+					};
+					const leftPrefix = getPrefix(left.parts);
+					const rightPrefix = getPrefix(right.parts);
+					const leftSuffix = getSuffix(left.parts);
+					const rightSuffix = getSuffix(right.parts);
+					const lenPrefix = Math.min(leftPrefix.length, rightPrefix.length);
+					const lenSuffix = Math.min(leftSuffix.length, rightSuffix.length);
+					if (
+						leftPrefix.slice(0, lenPrefix) !==
+							rightPrefix.slice(0, lenPrefix) ||
+						leftSuffix.slice(-lenSuffix) !== rightSuffix.slice(-lenSuffix)
+					) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+				};
+
+				const handleStrictEqualityComparison = eql => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					res.setRange(expr.range);
+
+					const leftConst = left.isCompileTimeValue();
+					const rightConst = right.isCompileTimeValue();
+
+					if (leftConst && rightConst) {
+						return res
+							.setBoolean(
+								eql ===
+									(left.asCompileTimeValue() === right.asCompileTimeValue())
+							)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+
+					if (left.isArray() && right.isArray()) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+					if (left.isTemplateString() && right.isTemplateString()) {
+						return handleTemplateStringCompare(left, right, res, eql);
+					}
+
+					const leftPrimitive = left.isPrimitiveType();
+					const rightPrimitive = right.isPrimitiveType();
+
+					if (
+						// Primitive !== Object or
+						// compile-time object types are never equal to something at runtime
+						(leftPrimitive === false &&
+							(leftConst || rightPrimitive === true)) ||
+						(rightPrimitive === false &&
+							(rightConst || leftPrimitive === true)) ||
+						// Different nullish or boolish status also means not equal
+						isAlwaysDifferent(left.asBool(), right.asBool()) ||
+						isAlwaysDifferent(left.asNullish(), right.asNullish())
+					) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+				};
+
+				const handleAbstractEqualityComparison = eql => {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					res.setRange(expr.range);
+
+					const leftConst = left.isCompileTimeValue();
+					const rightConst = right.isCompileTimeValue();
+
+					if (leftConst && rightConst) {
+						return res
+							.setBoolean(
+								eql ===
+									// eslint-disable-next-line eqeqeq
+									(left.asCompileTimeValue() == right.asCompileTimeValue())
+							)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+
+					if (left.isArray() && right.isArray()) {
+						return res
+							.setBoolean(!eql)
+							.setSideEffects(
+								left.couldHaveSideEffects() || right.couldHaveSideEffects()
+							);
+					}
+					if (left.isTemplateString() && right.isTemplateString()) {
+						return handleTemplateStringCompare(left, right, res, eql);
+					}
+				};
+
+				if (expr.operator === "+") {
+					const left = this.evaluateExpression(expr.left);
+					if (!left) return;
+					const right = this.evaluateExpression(expr.right);
+					if (!right) return;
+					const res = new BasicEvaluatedExpression();
+					if (left.isString()) {
+						if (right.isString()) {
+							res.setString(left.string + right.string);
+						} else if (right.isNumber()) {
+							res.setString(left.string + right.number);
+						} else if (
+							right.isWrapped() &&
+							right.prefix &&
+							right.prefix.isString()
+						) {
+							// "left" + ("prefix" + inner + "postfix")
+							// => ("leftPrefix" + inner + "postfix")
+							res.setWrapped(
+								new BasicEvaluatedExpression()
+									.setString(left.string + right.prefix.string)
+									.setRange(joinRanges(left.range, right.prefix.range)),
+								right.postfix,
+								right.wrappedInnerExpressions
+							);
+						} else if (right.isWrapped()) {
+							// "left" + ([null] + inner + "postfix")
+							// => ("left" + inner + "postfix")
+							res.setWrapped(
+								left,
+								right.postfix,
+								right.wrappedInnerExpressions
+							);
+						} else {
+							// "left" + expr
+							// => ("left" + expr + "")
+							res.setWrapped(left, null, [right]);
+						}
+					} else if (left.isNumber()) {
+						if (right.isString()) {
+							res.setString(left.number + right.string);
+						} else if (right.isNumber()) {
+							res.setNumber(left.number + right.number);
+						} else {
+							return;
+						}
+					} else if (left.isBigInt()) {
+						if (right.isBigInt()) {
+							res.setBigInt(left.bigint + right.bigint);
+						}
+					} else if (left.isWrapped()) {
+						if (left.postfix && left.postfix.isString() && right.isString()) {
+							// ("prefix" + inner + "postfix") + "right"
+							// => ("prefix" + inner + "postfixRight")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(left.postfix.string + right.string)
+									.setRange(joinRanges(left.postfix.range, right.range)),
+								left.wrappedInnerExpressions
+							);
+						} else if (
+							left.postfix &&
+							left.postfix.isString() &&
+							right.isNumber()
+						) {
+							// ("prefix" + inner + "postfix") + 123
+							// => ("prefix" + inner + "postfix123")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(left.postfix.string + right.number)
+									.setRange(joinRanges(left.postfix.range, right.range)),
+								left.wrappedInnerExpressions
+							);
+						} else if (right.isString()) {
+							// ("prefix" + inner + [null]) + "right"
+							// => ("prefix" + inner + "right")
+							res.setWrapped(left.prefix, right, left.wrappedInnerExpressions);
+						} else if (right.isNumber()) {
+							// ("prefix" + inner + [null]) + 123
+							// => ("prefix" + inner + "123")
+							res.setWrapped(
+								left.prefix,
+								new BasicEvaluatedExpression()
+									.setString(right.number + "")
+									.setRange(right.range),
+								left.wrappedInnerExpressions
+							);
+						} else if (right.isWrapped()) {
+							// ("prefix1" + inner1 + "postfix1") + ("prefix2" + inner2 + "postfix2")
+							// ("prefix1" + inner1 + "postfix1" + "prefix2" + inner2 + "postfix2")
+							res.setWrapped(
+								left.prefix,
+								right.postfix,
+								left.wrappedInnerExpressions &&
+									right.wrappedInnerExpressions &&
+									left.wrappedInnerExpressions
+										.concat(left.postfix ? [left.postfix] : [])
+										.concat(right.prefix ? [right.prefix] : [])
+										.concat(right.wrappedInnerExpressions)
+							);
+						} else {
+							// ("prefix" + inner + postfix) + expr
+							// => ("prefix" + inner + postfix + expr + [null])
+							res.setWrapped(
+								left.prefix,
+								null,
+								left.wrappedInnerExpressions &&
+									left.wrappedInnerExpressions.concat(
+										left.postfix ? [left.postfix, right] : [right]
+									)
+							);
+						}
+					} else {
+						if (right.isString()) {
+							// left + "right"
+							// => ([null] + left + "right")
+							res.setWrapped(null, right, [left]);
+						} else if (right.isWrapped()) {
+							// left + (prefix + inner + "postfix")
+							// => ([null] + left + prefix + inner + "postfix")
+							res.setWrapped(
+								null,
+								right.postfix,
+								right.wrappedInnerExpressions &&
+									(right.prefix ? [left, right.prefix] : [left]).concat(
+										right.wrappedInnerExpressions
+									)
+							);
+						} else {
+							return;
+						}
+					}
+					if (left.couldHaveSideEffects() || right.couldHaveSideEffects())
+						res.setSideEffects();
+					res.setRange(expr.range);
+					return res;
+				} else if (expr.operator === "-") {
+					return handleConstOperation((l, r) => l - r);
+				} else if (expr.operator === "*") {
+					return handleConstOperation((l, r) => l * r);
+				} else if (expr.operator === "/") {
+					return handleConstOperation((l, r) => l / r);
+				} else if (expr.operator === "**") {
+					return handleConstOperation((l, r) => l ** r);
+				} else if (expr.operator === "===") {
+					return handleStrictEqualityComparison(true);
+				} else if (expr.operator === "==") {
+					return handleAbstractEqualityComparison(true);
+				} else if (expr.operator === "!==") {
+					return handleStrictEqualityComparison(false);
+				} else if (expr.operator === "!=") {
+					return handleAbstractEqualityComparison(false);
+				} else if (expr.operator === "&") {
+					return handleConstOperation((l, r) => l & r);
+				} else if (expr.operator === "|") {
+					return handleConstOperation((l, r) => l | r);
+				} else if (expr.operator === "^") {
+					return handleConstOperation((l, r) => l ^ r);
+				} else if (expr.operator === ">>>") {
+					return handleConstOperation((l, r) => l >>> r);
+				} else if (expr.operator === ">>") {
+					return handleConstOperation((l, r) => l >> r);
+				} else if (expr.operator === "<<") {
+					return handleConstOperation((l, r) => l << r);
+				} else if (expr.operator === "<") {
+					return handleConstOperation((l, r) => l < r);
+				} else if (expr.operator === ">") {
+					return handleConstOperation((l, r) => l > r);
+				} else if (expr.operator === "<=") {
+					return handleConstOperation((l, r) => l <= r);
+				} else if (expr.operator === ">=") {
+					return handleConstOperation((l, r) => l >= r);
+				}
+			});
+		this.hooks.evaluate
+			.for("UnaryExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {UnaryExpressionNode} */ (_expr);
+
+				const handleConstOperation = fn => {
+					const argument = this.evaluateExpression(expr.argument);
+					if (!argument || !argument.isCompileTimeValue()) return;
+					const result = fn(argument.asCompileTimeValue());
+					return valueAsExpression(
+						result,
+						expr,
+						argument.couldHaveSideEffects()
+					);
+				};
+
+				if (expr.operator === "typeof") {
+					switch (expr.argument.type) {
+						case "Identifier": {
+							const res = this.callHooksForName(
+								this.hooks.evaluateTypeof,
+								expr.argument.name,
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
+						}
+						case "MetaProperty": {
+							const res = this.callHooksForName(
+								this.hooks.evaluateTypeof,
+								getRootName(expr.argument),
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
+						}
+						case "MemberExpression": {
+							const res = this.callHooksForExpression(
+								this.hooks.evaluateTypeof,
+								expr.argument,
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
+						}
+						case "ChainExpression": {
+							const res = this.callHooksForExpression(
+								this.hooks.evaluateTypeof,
+								expr.argument.expression,
+								expr
+							);
+							if (res !== undefined) return res;
+							break;
+						}
+						case "FunctionExpression": {
+							return new BasicEvaluatedExpression()
+								.setString("function")
+								.setRange(expr.range);
+						}
+					}
+					const arg = this.evaluateExpression(expr.argument);
+					if (arg.isUnknown()) return;
+					if (arg.isString()) {
+						return new BasicEvaluatedExpression()
+							.setString("string")
+							.setRange(expr.range);
+					}
+					if (arg.isWrapped()) {
+						return new BasicEvaluatedExpression()
+							.setString("string")
+							.setSideEffects()
+							.setRange(expr.range);
+					}
+					if (arg.isUndefined()) {
+						return new BasicEvaluatedExpression()
+							.setString("undefined")
+							.setRange(expr.range);
+					}
+					if (arg.isNumber()) {
+						return new BasicEvaluatedExpression()
+							.setString("number")
+							.setRange(expr.range);
+					}
+					if (arg.isBigInt()) {
+						return new BasicEvaluatedExpression()
+							.setString("bigint")
+							.setRange(expr.range);
+					}
+					if (arg.isBoolean()) {
+						return new BasicEvaluatedExpression()
+							.setString("boolean")
+							.setRange(expr.range);
+					}
+					if (arg.isConstArray() || arg.isRegExp() || arg.isNull()) {
+						return new BasicEvaluatedExpression()
+							.setString("object")
+							.setRange(expr.range);
+					}
+					if (arg.isArray()) {
+						return new BasicEvaluatedExpression()
+							.setString("object")
+							.setSideEffects(arg.couldHaveSideEffects())
+							.setRange(expr.range);
+					}
+				} else if (expr.operator === "!") {
+					const argument = this.evaluateExpression(expr.argument);
+					if (!argument) return;
+					const bool = argument.asBool();
+					if (typeof bool !== "boolean") return;
+					return new BasicEvaluatedExpression()
+						.setBoolean(!bool)
+						.setSideEffects(argument.couldHaveSideEffects())
+						.setRange(expr.range);
+				} else if (expr.operator === "~") {
+					return handleConstOperation(v => ~v);
+				} else if (expr.operator === "+") {
+					return handleConstOperation(v => +v);
+				} else if (expr.operator === "-") {
+					return handleConstOperation(v => -v);
+				}
+			});
+		this.hooks.evaluateTypeof.for("undefined").tap("JavascriptParser", expr => {
+			return new BasicEvaluatedExpression()
+				.setString("undefined")
+				.setRange(expr.range);
+		});
+		this.hooks.evaluate.for("Identifier").tap("JavascriptParser", expr => {
+			if (/** @type {IdentifierNode} */ (expr).name === "undefined") {
+				return new BasicEvaluatedExpression()
+					.setUndefined()
+					.setRange(expr.range);
+			}
+		});
+		/**
+		 * @param {string} exprType expression type name
+		 * @param {function(ExpressionNode): GetInfoResult | undefined} getInfo get info
+		 * @returns {void}
+		 */
+		const tapEvaluateWithVariableInfo = (exprType, getInfo) => {
+			/** @type {ExpressionNode | undefined} */
+			let cachedExpression = undefined;
+			/** @type {GetInfoResult | undefined} */
+			let cachedInfo = undefined;
+			this.hooks.evaluate.for(exprType).tap("JavascriptParser", expr => {
+				const expression = /** @type {MemberExpressionNode} */ (expr);
+
+				const info = getInfo(expr);
+				if (info !== undefined) {
+					return this.callHooksForInfoWithFallback(
+						this.hooks.evaluateIdentifier,
+						info.name,
+						name => {
+							cachedExpression = expression;
+							cachedInfo = info;
+						},
+						name => {
+							const hook = this.hooks.evaluateDefinedIdentifier.get(name);
+							if (hook !== undefined) {
+								return hook.call(expression);
+							}
+						},
+						expression
+					);
+				}
+			});
+			this.hooks.evaluate
+				.for(exprType)
+				.tap({ name: "JavascriptParser", stage: 100 }, expr => {
+					const info = cachedExpression === expr ? cachedInfo : getInfo(expr);
+					if (info !== undefined) {
+						return new BasicEvaluatedExpression()
+							.setIdentifier(info.name, info.rootInfo, info.getMembers)
+							.setRange(expr.range);
+					}
+				});
+			this.hooks.finish.tap("JavascriptParser", () => {
+				// Cleanup for GC
+				cachedExpression = cachedInfo = undefined;
+			});
+		};
+		tapEvaluateWithVariableInfo("Identifier", expr => {
+			const info = this.getVariableInfo(
+				/** @type {IdentifierNode} */ (expr).name
+			);
+			if (
+				typeof info === "string" ||
+				(info instanceof VariableInfo && typeof info.freeName === "string")
+			) {
+				return { name: info, rootInfo: info, getMembers: () => [] };
+			}
+		});
+		tapEvaluateWithVariableInfo("ThisExpression", expr => {
+			const info = this.getVariableInfo("this");
+			if (
+				typeof info === "string" ||
+				(info instanceof VariableInfo && typeof info.freeName === "string")
+			) {
+				return { name: info, rootInfo: info, getMembers: () => [] };
+			}
+		});
+		this.hooks.evaluate.for("MetaProperty").tap("JavascriptParser", expr => {
+			const metaProperty = /** @type {MetaPropertyNode} */ (expr);
+
+			return this.callHooksForName(
+				this.hooks.evaluateIdentifier,
+				getRootName(expr),
+				metaProperty
+			);
+		});
+		tapEvaluateWithVariableInfo("MemberExpression", expr =>
+			this.getMemberExpressionInfo(
+				/** @type {MemberExpressionNode} */ (expr),
+				ALLOWED_MEMBER_TYPES_EXPRESSION
+			)
+		);
+
+		this.hooks.evaluate.for("CallExpression").tap("JavascriptParser", _expr => {
+			const expr = /** @type {CallExpressionNode} */ (_expr);
+			if (
+				expr.callee.type !== "MemberExpression" ||
+				expr.callee.property.type !==
+					(expr.callee.computed ? "Literal" : "Identifier")
+			) {
+				return;
+			}
+
+			// type Super also possible here
+			const param = this.evaluateExpression(
+				/** @type {ExpressionNode} */ (expr.callee.object)
+			);
+			if (!param) return;
+			const property =
+				expr.callee.property.type === "Literal"
+					? `${expr.callee.property.value}`
+					: expr.callee.property.name;
+			const hook = this.hooks.evaluateCallExpressionMember.get(property);
+			if (hook !== undefined) {
+				return hook.call(expr, param);
+			}
+		});
+		this.hooks.evaluateCallExpressionMember
+			.for("indexOf")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length === 0) return;
+				const [arg1, arg2] = expr.arguments;
+				if (arg1.type === "SpreadElement") return;
+				const arg1Eval = this.evaluateExpression(arg1);
+				if (!arg1Eval.isString()) return;
+				const arg1Value = arg1Eval.string;
+
+				let result;
+				if (arg2) {
+					if (arg2.type === "SpreadElement") return;
+					const arg2Eval = this.evaluateExpression(arg2);
+					if (!arg2Eval.isNumber()) return;
+					result = param.string.indexOf(arg1Value, arg2Eval.number);
+				} else {
+					result = param.string.indexOf(arg1Value);
+				}
+				return new BasicEvaluatedExpression()
+					.setNumber(result)
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		this.hooks.evaluateCallExpressionMember
+			.for("replace")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length !== 2) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				if (expr.arguments[1].type === "SpreadElement") return;
+				let arg1 = this.evaluateExpression(expr.arguments[0]);
+				let arg2 = this.evaluateExpression(expr.arguments[1]);
+				if (!arg1.isString() && !arg1.isRegExp()) return;
+				const arg1Value = arg1.regExp || arg1.string;
+				if (!arg2.isString()) return;
+				const arg2Value = arg2.string;
+				return new BasicEvaluatedExpression()
+					.setString(param.string.replace(arg1Value, arg2Value))
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		["substr", "substring", "slice"].forEach(fn => {
+			this.hooks.evaluateCallExpressionMember
+				.for(fn)
+				.tap("JavascriptParser", (expr, param) => {
+					if (!param.isString()) return;
+					let arg1;
+					let result,
+						str = param.string;
+					switch (expr.arguments.length) {
+						case 1:
+							if (expr.arguments[0].type === "SpreadElement") return;
+							arg1 = this.evaluateExpression(expr.arguments[0]);
+							if (!arg1.isNumber()) return;
+							result = str[fn](arg1.number);
+							break;
+						case 2: {
+							if (expr.arguments[0].type === "SpreadElement") return;
+							if (expr.arguments[1].type === "SpreadElement") return;
+							arg1 = this.evaluateExpression(expr.arguments[0]);
+							const arg2 = this.evaluateExpression(expr.arguments[1]);
+							if (!arg1.isNumber()) return;
+							if (!arg2.isNumber()) return;
+							result = str[fn](arg1.number, arg2.number);
+							break;
+						}
+						default:
+							return;
+					}
+					return new BasicEvaluatedExpression()
+						.setString(result)
+						.setSideEffects(param.couldHaveSideEffects())
+						.setRange(expr.range);
+				});
+		});
+
+		/**
+		 * @param {"cooked" | "raw"} kind kind of values to get
+		 * @param {TemplateLiteralNode} templateLiteralExpr TemplateLiteral expr
+		 * @returns {{quasis: BasicEvaluatedExpression[], parts: BasicEvaluatedExpression[]}} Simplified template
+		 */
+		const getSimplifiedTemplateResult = (kind, templateLiteralExpr) => {
+			/** @type {BasicEvaluatedExpression[]} */
+			const quasis = [];
+			/** @type {BasicEvaluatedExpression[]} */
+			const parts = [];
+
+			for (let i = 0; i < templateLiteralExpr.quasis.length; i++) {
+				const quasiExpr = templateLiteralExpr.quasis[i];
+				const quasi = quasiExpr.value[kind];
+
+				if (i > 0) {
+					const prevExpr = parts[parts.length - 1];
+					const expr = this.evaluateExpression(
+						templateLiteralExpr.expressions[i - 1]
+					);
+					const exprAsString = expr.asString();
+					if (
+						typeof exprAsString === "string" &&
+						!expr.couldHaveSideEffects()
+					) {
+						// We can merge quasi + expr + quasi when expr
+						// is a const string
+
+						prevExpr.setString(prevExpr.string + exprAsString + quasi);
+						prevExpr.setRange([prevExpr.range[0], quasiExpr.range[1]]);
+						// We unset the expression as it doesn't match to a single expression
+						prevExpr.setExpression(undefined);
+						continue;
+					}
+					parts.push(expr);
+				}
+
+				const part = new BasicEvaluatedExpression()
+					.setString(quasi)
+					.setRange(quasiExpr.range)
+					.setExpression(quasiExpr);
+				quasis.push(part);
+				parts.push(part);
+			}
+			return {
+				quasis,
+				parts
+			};
+		};
+
+		this.hooks.evaluate
+			.for("TemplateLiteral")
+			.tap("JavascriptParser", _node => {
+				const node = /** @type {TemplateLiteralNode} */ (_node);
+
+				const { quasis, parts } = getSimplifiedTemplateResult("cooked", node);
+				if (parts.length === 1) {
+					return parts[0].setRange(node.range);
+				}
+				return new BasicEvaluatedExpression()
+					.setTemplateString(quasis, parts, "cooked")
+					.setRange(node.range);
+			});
+		this.hooks.evaluate
+			.for("TaggedTemplateExpression")
+			.tap("JavascriptParser", _node => {
+				const node = /** @type {TaggedTemplateExpressionNode} */ (_node);
+				const tag = this.evaluateExpression(node.tag);
+
+				if (tag.isIdentifier() && tag.identifier === "String.raw") {
+					const { quasis, parts } = getSimplifiedTemplateResult(
+						"raw",
+						node.quasi
+					);
+					return new BasicEvaluatedExpression()
+						.setTemplateString(quasis, parts, "raw")
+						.setRange(node.range);
+				}
+			});
+
+		this.hooks.evaluateCallExpressionMember
+			.for("concat")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString() && !param.isWrapped()) return;
+
+				let stringSuffix = null;
+				let hasUnknownParams = false;
+				const innerExpressions = [];
+				for (let i = expr.arguments.length - 1; i >= 0; i--) {
+					const arg = expr.arguments[i];
+					if (arg.type === "SpreadElement") return;
+					const argExpr = this.evaluateExpression(arg);
+					if (
+						hasUnknownParams ||
+						(!argExpr.isString() && !argExpr.isNumber())
+					) {
+						hasUnknownParams = true;
+						innerExpressions.push(argExpr);
+						continue;
+					}
+
+					const value = argExpr.isString()
+						? argExpr.string
+						: "" + argExpr.number;
+
+					const newString = value + (stringSuffix ? stringSuffix.string : "");
+					const newRange = [
+						argExpr.range[0],
+						(stringSuffix || argExpr).range[1]
+					];
+					stringSuffix = new BasicEvaluatedExpression()
+						.setString(newString)
+						.setSideEffects(
+							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
+								argExpr.couldHaveSideEffects()
+						)
+						.setRange(newRange);
+				}
+
+				if (hasUnknownParams) {
+					const prefix = param.isString() ? param : param.prefix;
+					const inner =
+						param.isWrapped() && param.wrappedInnerExpressions
+							? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+							: innerExpressions.reverse();
+					return new BasicEvaluatedExpression()
+						.setWrapped(prefix, stringSuffix, inner)
+						.setRange(expr.range);
+				} else if (param.isWrapped()) {
+					const postfix = stringSuffix || param.postfix;
+					const inner = param.wrappedInnerExpressions
+						? param.wrappedInnerExpressions.concat(innerExpressions.reverse())
+						: innerExpressions.reverse();
+					return new BasicEvaluatedExpression()
+						.setWrapped(param.prefix, postfix, inner)
+						.setRange(expr.range);
+				} else {
+					const newString =
+						param.string + (stringSuffix ? stringSuffix.string : "");
+					return new BasicEvaluatedExpression()
+						.setString(newString)
+						.setSideEffects(
+							(stringSuffix && stringSuffix.couldHaveSideEffects()) ||
+								param.couldHaveSideEffects()
+						)
+						.setRange(expr.range);
+				}
+			});
+		this.hooks.evaluateCallExpressionMember
+			.for("split")
+			.tap("JavascriptParser", (expr, param) => {
+				if (!param.isString()) return;
+				if (expr.arguments.length !== 1) return;
+				if (expr.arguments[0].type === "SpreadElement") return;
+				let result;
+				const arg = this.evaluateExpression(expr.arguments[0]);
+				if (arg.isString()) {
+					result = param.string.split(arg.string);
+				} else if (arg.isRegExp()) {
+					result = param.string.split(arg.regExp);
+				} else {
+					return;
+				}
+				return new BasicEvaluatedExpression()
+					.setArray(result)
+					.setSideEffects(param.couldHaveSideEffects())
+					.setRange(expr.range);
+			});
+		this.hooks.evaluate
+			.for("ConditionalExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ConditionalExpressionNode} */ (_expr);
+
+				const condition = this.evaluateExpression(expr.test);
+				const conditionValue = condition.asBool();
+				let res;
+				if (conditionValue === undefined) {
+					const consequent = this.evaluateExpression(expr.consequent);
+					const alternate = this.evaluateExpression(expr.alternate);
+					if (!consequent || !alternate) return;
+					res = new BasicEvaluatedExpression();
+					if (consequent.isConditional()) {
+						res.setOptions(consequent.options);
+					} else {
+						res.setOptions([consequent]);
+					}
+					if (alternate.isConditional()) {
+						res.addOptions(alternate.options);
+					} else {
+						res.addOptions([alternate]);
+					}
+				} else {
+					res = this.evaluateExpression(
+						conditionValue ? expr.consequent : expr.alternate
+					);
+					if (condition.couldHaveSideEffects()) res.setSideEffects();
+				}
+				res.setRange(expr.range);
+				return res;
+			});
+		this.hooks.evaluate
+			.for("ArrayExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ArrayExpressionNode} */ (_expr);
+
+				const items = expr.elements.map(element => {
+					return (
+						element !== null &&
+						element.type !== "SpreadElement" &&
+						this.evaluateExpression(element)
+					);
+				});
+				if (!items.every(Boolean)) return;
+				return new BasicEvaluatedExpression()
+					.setItems(items)
+					.setRange(expr.range);
+			});
+		this.hooks.evaluate
+			.for("ChainExpression")
+			.tap("JavascriptParser", _expr => {
+				const expr = /** @type {ChainExpressionNode} */ (_expr);
+				/** @type {ExpressionNode[]} */
+				const optionalExpressionsStack = [];
+				/** @type {ExpressionNode|SuperNode} */
+				let next = expr.expression;
+
+				while (
+					next.type === "MemberExpression" ||
+					next.type === "CallExpression"
+				) {
+					if (next.type === "MemberExpression") {
+						if (next.optional) {
+							// SuperNode can not be optional
+							optionalExpressionsStack.push(
+								/** @type {ExpressionNode} */ (next.object)
+							);
+						}
+						next = next.object;
+					} else {
+						if (next.optional) {
+							// SuperNode can not be optional
+							optionalExpressionsStack.push(
+								/** @type {ExpressionNode} */ (next.callee)
+							);
+						}
+						next = next.callee;
+					}
+				}
+
+				while (optionalExpressionsStack.length > 0) {
+					const expression = optionalExpressionsStack.pop();
+					const evaluated = this.evaluateExpression(expression);
+
+					if (evaluated && evaluated.asNullish()) {
+						return evaluated.setRange(_expr.range);
+					}
+				}
+				return this.evaluateExpression(expr.expression);
+			});
+	}
+
+	getRenameIdentifier(expr) {
+		const result = this.evaluateExpression(expr);
+		if (result && result.isIdentifier()) {
+			return result.identifier;
+		}
+	}
+
+	/**
+	 * @param {ClassExpressionNode | ClassDeclarationNode} classy a class node
+	 * @returns {void}
+	 */
+	walkClass(classy) {
+		if (classy.superClass) {
+			if (!this.hooks.classExtendsExpression.call(classy.superClass, classy)) {
+				this.walkExpression(classy.superClass);
+			}
+		}
+		if (classy.body && classy.body.type === "ClassBody") {
+			for (const classElement of /** @type {TODO} */ (classy.body.body)) {
+				if (!this.hooks.classBodyElement.call(classElement, classy)) {
+					if (classElement.computed && classElement.key) {
+						this.walkExpression(classElement.key);
+					}
+					if (classElement.value) {
+						if (
+							!this.hooks.classBodyValue.call(
+								classElement.value,
+								classElement,
+								classy
+							)
+						) {
+							const wasTopLevel = this.scope.topLevelScope;
+							this.scope.topLevelScope = false;
+							this.walkExpression(classElement.value);
+							this.scope.topLevelScope = wasTopLevel;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Pre walking iterates the scope for variable declarations
+	preWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.preWalkStatement(statement);
+		}
+	}
+
+	// Block pre walking iterates the scope for block variable declarations
+	blockPreWalkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.blockPreWalkStatement(statement);
+		}
+	}
+
+	// Walking iterates the statements and expressions and processes them
+	walkStatements(statements) {
+		for (let index = 0, len = statements.length; index < len; index++) {
+			const statement = statements[index];
+			this.walkStatement(statement);
+		}
+	}
+
+	preWalkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.preStatement.call(statement)) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "BlockStatement":
+				this.preWalkBlockStatement(statement);
+				break;
+			case "DoWhileStatement":
+				this.preWalkDoWhileStatement(statement);
+				break;
+			case "ForInStatement":
+				this.preWalkForInStatement(statement);
+				break;
+			case "ForOfStatement":
+				this.preWalkForOfStatement(statement);
+				break;
+			case "ForStatement":
+				this.preWalkForStatement(statement);
+				break;
+			case "FunctionDeclaration":
+				this.preWalkFunctionDeclaration(statement);
+				break;
+			case "IfStatement":
+				this.preWalkIfStatement(statement);
+				break;
+			case "LabeledStatement":
+				this.preWalkLabeledStatement(statement);
+				break;
+			case "SwitchStatement":
+				this.preWalkSwitchStatement(statement);
+				break;
+			case "TryStatement":
+				this.preWalkTryStatement(statement);
+				break;
+			case "VariableDeclaration":
+				this.preWalkVariableDeclaration(statement);
+				break;
+			case "WhileStatement":
+				this.preWalkWhileStatement(statement);
+				break;
+			case "WithStatement":
+				this.preWalkWithStatement(statement);
+				break;
+		}
+		this.prevStatement = this.statementPath.pop();
+	}
+
+	blockPreWalkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.blockPreStatement.call(statement)) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "ImportDeclaration":
+				this.blockPreWalkImportDeclaration(statement);
+				break;
+			case "ExportAllDeclaration":
+				this.blockPreWalkExportAllDeclaration(statement);
+				break;
+			case "ExportDefaultDeclaration":
+				this.blockPreWalkExportDefaultDeclaration(statement);
+				break;
+			case "ExportNamedDeclaration":
+				this.blockPreWalkExportNamedDeclaration(statement);
+				break;
+			case "VariableDeclaration":
+				this.blockPreWalkVariableDeclaration(statement);
+				break;
+			case "ClassDeclaration":
+				this.blockPreWalkClassDeclaration(statement);
+				break;
+		}
+		this.prevStatement = this.statementPath.pop();
+	}
+
+	walkStatement(statement) {
+		this.statementPath.push(statement);
+		if (this.hooks.statement.call(statement) !== undefined) {
+			this.prevStatement = this.statementPath.pop();
+			return;
+		}
+		switch (statement.type) {
+			case "BlockStatement":
+				this.walkBlockStatement(statement);
+				break;
+			case "ClassDeclaration":
+				this.walkClassDeclaration(statement);
+				break;
+			case "DoWhileStatement":
+				this.walkDoWhileStatement(statement);
+				break;
+			case "ExportDefaultDeclaration":
+				this.walkExportDefaultDeclaration(statement);
+				break;
+			case "ExportNamedDeclaration":
+				this.walkExportNamedDeclaration(statement);
+				break;
+			case "ExpressionStatement":
+				this.walkExpressionStatement(statement);
+				break;
+			case "ForInStatement":
+				this.walkForInStatement(statement);
+				break;
+			case "ForOfStatement":
+				this.walkForOfStatement(statement);
+				break;
+			case "ForStatement":
+				this.walkForStatement(statement);
+				break;
+			case "FunctionDeclaration":
+				this.walkFunctionDeclaration(statement);
+				break;
+			case "IfStatement":
+				this.walkIfStatement(statement);
+				break;
+			case "LabeledStatement":
+				this.walkLabeledStatement(statement);
+				break;
+			case "ReturnStatement":
+				this.walkReturnStatement(statement);
+				break;
+			case "SwitchStatement":
+				this.walkSwitchStatement(statement);
+				break;
+			case "ThrowStatement":
+				this.walkThrowStatement(statement);
+				break;
+			case "TryStatement":
+				this.walkTryStatement(statement);
+				break;
+			case "VariableDeclaration":
+				this.walkVariableDeclaration(statement);
+				break;
+			case "WhileStatement":
+				this.walkWhileStatement(statement);
+				break;
+			case "WithStatement":
+				this.walkWithStatement(statement);
+				break;
+		}
+		this.prevStatement = this.statementPath.pop();
+	}
+
+	/**
+	 * Walks a statements that is nested within a parent statement
+	 * and can potentially be a non-block statement.
+	 * This enforces the nested statement to never be in ASI position.
+	 * @param {StatementNode} statement the nested statement
+	 * @returns {void}
+	 */
+	walkNestedStatement(statement) {
+		this.prevStatement = undefined;
+		this.walkStatement(statement);
+	}
+
+	// Real Statements
+	preWalkBlockStatement(statement) {
+		this.preWalkStatements(statement.body);
+	}
+
+	walkBlockStatement(statement) {
+		this.inBlockScope(() => {
+			const body = statement.body;
+			const prev = this.prevStatement;
+			this.blockPreWalkStatements(body);
+			this.prevStatement = prev;
+			this.walkStatements(body);
+		});
+	}
+
+	walkExpressionStatement(statement) {
+		this.walkExpression(statement.expression);
+	}
+
+	preWalkIfStatement(statement) {
+		this.preWalkStatement(statement.consequent);
+		if (statement.alternate) {
+			this.preWalkStatement(statement.alternate);
+		}
+	}
+
+	walkIfStatement(statement) {
+		const result = this.hooks.statementIf.call(statement);
+		if (result === undefined) {
+			this.walkExpression(statement.test);
+			this.walkNestedStatement(statement.consequent);
+			if (statement.alternate) {
+				this.walkNestedStatement(statement.alternate);
+			}
+		} else {
+			if (result) {
+				this.walkNestedStatement(statement.consequent);
+			} else if (statement.alternate) {
+				this.walkNestedStatement(statement.alternate);
+			}
+		}
+	}
+
+	preWalkLabeledStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	walkLabeledStatement(statement) {
+		const hook = this.hooks.label.get(statement.label.name);
+		if (hook !== undefined) {
+			const result = hook.call(statement);
+			if (result === true) return;
+		}
+		this.walkNestedStatement(statement.body);
+	}
+
+	preWalkWithStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	walkWithStatement(statement) {
+		this.walkExpression(statement.object);
+		this.walkNestedStatement(statement.body);
+	}
+
+	preWalkSwitchStatement(statement) {
+		this.preWalkSwitchCases(statement.cases);
+	}
+
+	walkSwitchStatement(statement) {
+		this.walkExpression(statement.discriminant);
+		this.walkSwitchCases(statement.cases);
+	}
+
+	walkTerminatingStatement(statement) {
+		if (statement.argument) this.walkExpression(statement.argument);
+	}
+
+	walkReturnStatement(statement) {
+		this.walkTerminatingStatement(statement);
+	}
+
+	walkThrowStatement(statement) {
+		this.walkTerminatingStatement(statement);
+	}
+
+	preWalkTryStatement(statement) {
+		this.preWalkStatement(statement.block);
+		if (statement.handler) this.preWalkCatchClause(statement.handler);
+		if (statement.finializer) this.preWalkStatement(statement.finializer);
+	}
+
+	walkTryStatement(statement) {
+		if (this.scope.inTry) {
+			this.walkStatement(statement.block);
+		} else {
+			this.scope.inTry = true;
+			this.walkStatement(statement.block);
+			this.scope.inTry = false;
+		}
+		if (statement.handler) this.walkCatchClause(statement.handler);
+		if (statement.finalizer) this.walkStatement(statement.finalizer);
+	}
+
+	preWalkWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	walkWhileStatement(statement) {
+		this.walkExpression(statement.test);
+		this.walkNestedStatement(statement.body);
+	}
+
+	preWalkDoWhileStatement(statement) {
+		this.preWalkStatement(statement.body);
+	}
+
+	walkDoWhileStatement(statement) {
+		this.walkNestedStatement(statement.body);
+		this.walkExpression(statement.test);
+	}
+
+	preWalkForStatement(statement) {
+		if (statement.init) {
+			if (statement.init.type === "VariableDeclaration") {
+				this.preWalkStatement(statement.init);
+			}
+		}
+		this.preWalkStatement(statement.body);
+	}
+
+	walkForStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.init) {
+				if (statement.init.type === "VariableDeclaration") {
+					this.blockPreWalkVariableDeclaration(statement.init);
+					this.prevStatement = undefined;
+					this.walkStatement(statement.init);
+				} else {
+					this.walkExpression(statement.init);
+				}
+			}
+			if (statement.test) {
+				this.walkExpression(statement.test);
+			}
+			if (statement.update) {
+				this.walkExpression(statement.update);
+			}
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
+	}
+
+	preWalkForInStatement(statement) {
+		if (statement.left.type === "VariableDeclaration") {
+			this.preWalkVariableDeclaration(statement.left);
+		}
+		this.preWalkStatement(statement.body);
+	}
+
+	walkForInStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.left.type === "VariableDeclaration") {
+				this.blockPreWalkVariableDeclaration(statement.left);
+				this.walkVariableDeclaration(statement.left);
+			} else {
+				this.walkPattern(statement.left);
+			}
+			this.walkExpression(statement.right);
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
+	}
+
+	preWalkForOfStatement(statement) {
+		if (statement.await && this.scope.topLevelScope === true) {
+			this.hooks.topLevelAwait.call(statement);
+		}
+		if (statement.left.type === "VariableDeclaration") {
+			this.preWalkVariableDeclaration(statement.left);
+		}
+		this.preWalkStatement(statement.body);
+	}
+
+	walkForOfStatement(statement) {
+		this.inBlockScope(() => {
+			if (statement.left.type === "VariableDeclaration") {
+				this.blockPreWalkVariableDeclaration(statement.left);
+				this.walkVariableDeclaration(statement.left);
+			} else {
+				this.walkPattern(statement.left);
+			}
+			this.walkExpression(statement.right);
+			const body = statement.body;
+			if (body.type === "BlockStatement") {
+				// no need to add additional scope
+				const prev = this.prevStatement;
+				this.blockPreWalkStatements(body.body);
+				this.prevStatement = prev;
+				this.walkStatements(body.body);
+			} else {
+				this.walkNestedStatement(body);
+			}
+		});
+	}
+
+	// Declarations
+	preWalkFunctionDeclaration(statement) {
+		if (statement.id) {
+			this.defineVariable(statement.id.name);
+		}
+	}
+
+	walkFunctionDeclaration(statement) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = false;
+		this.inFunctionScope(true, statement.params, () => {
+			for (const param of statement.params) {
+				this.walkPattern(param);
+			}
+			if (statement.body.type === "BlockStatement") {
+				this.detectMode(statement.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(statement.body);
+				this.prevStatement = prev;
+				this.walkStatement(statement.body);
+			} else {
+				this.walkExpression(statement.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
+	}
+
+	blockPreWalkImportDeclaration(statement) {
+		const source = statement.source.value;
+		this.hooks.import.call(statement, source);
+		for (const specifier of statement.specifiers) {
+			const name = specifier.local.name;
+			switch (specifier.type) {
+				case "ImportDefaultSpecifier":
+					if (
+						!this.hooks.importSpecifier.call(statement, source, "default", name)
+					) {
+						this.defineVariable(name);
+					}
+					break;
+				case "ImportSpecifier":
+					if (
+						!this.hooks.importSpecifier.call(
+							statement,
+							source,
+							specifier.imported.name,
+							name
+						)
+					) {
+						this.defineVariable(name);
+					}
+					break;
+				case "ImportNamespaceSpecifier":
+					if (!this.hooks.importSpecifier.call(statement, source, null, name)) {
+						this.defineVariable(name);
+					}
+					break;
+				default:
+					this.defineVariable(name);
+			}
+		}
+	}
+
+	enterDeclaration(declaration, onIdent) {
+		switch (declaration.type) {
+			case "VariableDeclaration":
+				for (const declarator of declaration.declarations) {
+					switch (declarator.type) {
+						case "VariableDeclarator": {
+							this.enterPattern(declarator.id, onIdent);
+							break;
+						}
+					}
+				}
+				break;
+			case "FunctionDeclaration":
+				this.enterPattern(declaration.id, onIdent);
+				break;
+			case "ClassDeclaration":
+				this.enterPattern(declaration.id, onIdent);
+				break;
+		}
+	}
+
+	blockPreWalkExportNamedDeclaration(statement) {
+		let source;
+		if (statement.source) {
+			source = statement.source.value;
+			this.hooks.exportImport.call(statement, source);
+		} else {
+			this.hooks.export.call(statement);
+		}
+		if (statement.declaration) {
+			if (
+				!this.hooks.exportDeclaration.call(statement, statement.declaration)
+			) {
+				const prev = this.prevStatement;
+				this.preWalkStatement(statement.declaration);
+				this.prevStatement = prev;
+				this.blockPreWalkStatement(statement.declaration);
+				let index = 0;
+				this.enterDeclaration(statement.declaration, def => {
+					this.hooks.exportSpecifier.call(statement, def, def, index++);
+				});
+			}
+		}
+		if (statement.specifiers) {
+			for (
+				let specifierIndex = 0;
+				specifierIndex < statement.specifiers.length;
+				specifierIndex++
+			) {
+				const specifier = statement.specifiers[specifierIndex];
+				switch (specifier.type) {
+					case "ExportSpecifier": {
+						const name = specifier.exported.name;
+						if (source) {
+							this.hooks.exportImportSpecifier.call(
+								statement,
+								source,
+								specifier.local.name,
+								name,
+								specifierIndex
+							);
+						} else {
+							this.hooks.exportSpecifier.call(
+								statement,
+								specifier.local.name,
+								name,
+								specifierIndex
+							);
+						}
+						break;
+					}
+				}
+			}
+		}
+	}
+
+	walkExportNamedDeclaration(statement) {
+		if (statement.declaration) {
+			this.walkStatement(statement.declaration);
+		}
+	}
+
+	blockPreWalkExportDefaultDeclaration(statement) {
+		const prev = this.prevStatement;
+		this.preWalkStatement(statement.declaration);
+		this.prevStatement = prev;
+		this.blockPreWalkStatement(statement.declaration);
+		if (
+			statement.declaration.id &&
+			statement.declaration.type !== "FunctionExpression" &&
+			statement.declaration.type !== "ClassExpression"
+		) {
+			this.hooks.exportSpecifier.call(
+				statement,
+				statement.declaration.id.name,
+				"default",
+				undefined
+			);
+		}
+	}
+
+	walkExportDefaultDeclaration(statement) {
+		this.hooks.export.call(statement);
+		if (
+			statement.declaration.id &&
+			statement.declaration.type !== "FunctionExpression" &&
+			statement.declaration.type !== "ClassExpression"
+		) {
+			if (
+				!this.hooks.exportDeclaration.call(statement, statement.declaration)
+			) {
+				this.walkStatement(statement.declaration);
+			}
+		} else {
+			// Acorn parses `export default function() {}` as `FunctionDeclaration` and
+			// `export default class {}` as `ClassDeclaration`, both with `id = null`.
+			// These nodes must be treated as expressions.
+			if (
+				statement.declaration.type === "FunctionDeclaration" ||
+				statement.declaration.type === "ClassDeclaration"
+			) {
+				this.walkStatement(statement.declaration);
+			} else {
+				this.walkExpression(statement.declaration);
+			}
+			if (!this.hooks.exportExpression.call(statement, statement.declaration)) {
+				this.hooks.exportSpecifier.call(
+					statement,
+					statement.declaration,
+					"default",
+					undefined
+				);
+			}
+		}
+	}
+
+	blockPreWalkExportAllDeclaration(statement) {
+		const source = statement.source.value;
+		const name = statement.exported ? statement.exported.name : null;
+		this.hooks.exportImport.call(statement, source);
+		this.hooks.exportImportSpecifier.call(statement, source, null, name, 0);
+	}
+
+	preWalkVariableDeclaration(statement) {
+		if (statement.kind !== "var") return;
+		this._preWalkVariableDeclaration(statement, this.hooks.varDeclarationVar);
+	}
+
+	blockPreWalkVariableDeclaration(statement) {
+		if (statement.kind === "var") return;
+		const hookMap =
+			statement.kind === "const"
+				? this.hooks.varDeclarationConst
+				: this.hooks.varDeclarationLet;
+		this._preWalkVariableDeclaration(statement, hookMap);
+	}
+
+	_preWalkVariableDeclaration(statement, hookMap) {
+		for (const declarator of statement.declarations) {
+			switch (declarator.type) {
+				case "VariableDeclarator": {
+					if (!this.hooks.preDeclarator.call(declarator, statement)) {
+						this.enterPattern(declarator.id, (name, decl) => {
+							let hook = hookMap.get(name);
+							if (hook === undefined || !hook.call(decl)) {
+								hook = this.hooks.varDeclaration.get(name);
+								if (hook === undefined || !hook.call(decl)) {
+									this.defineVariable(name);
+								}
+							}
+						});
+					}
+					break;
+				}
+			}
+		}
+	}
+
+	walkVariableDeclaration(statement) {
+		for (const declarator of statement.declarations) {
+			switch (declarator.type) {
+				case "VariableDeclarator": {
+					const renameIdentifier =
+						declarator.init && this.getRenameIdentifier(declarator.init);
+					if (renameIdentifier && declarator.id.type === "Identifier") {
+						const hook = this.hooks.canRename.get(renameIdentifier);
+						if (hook !== undefined && hook.call(declarator.init)) {
+							// renaming with "var a = b;"
+							const hook = this.hooks.rename.get(renameIdentifier);
+							if (hook === undefined || !hook.call(declarator.init)) {
+								this.setVariable(declarator.id.name, renameIdentifier);
+							}
+							break;
+						}
+					}
+					if (!this.hooks.declarator.call(declarator, statement)) {
+						this.walkPattern(declarator.id);
+						if (declarator.init) this.walkExpression(declarator.init);
+					}
+					break;
+				}
+			}
+		}
+	}
+
+	blockPreWalkClassDeclaration(statement) {
+		if (statement.id) {
+			this.defineVariable(statement.id.name);
+		}
+	}
+
+	walkClassDeclaration(statement) {
+		this.walkClass(statement);
+	}
+
+	preWalkSwitchCases(switchCases) {
+		for (let index = 0, len = switchCases.length; index < len; index++) {
+			const switchCase = switchCases[index];
+			this.preWalkStatements(switchCase.consequent);
+		}
+	}
+
+	walkSwitchCases(switchCases) {
+		this.inBlockScope(() => {
+			const len = switchCases.length;
+
+			// we need to pre walk all statements first since we can have invalid code
+			// import A from "module";
+			// switch(1) {
+			//    case 1:
+			//      console.log(A); // should fail at runtime
+			//    case 2:
+			//      const A = 1;
+			// }
+			for (let index = 0; index < len; index++) {
+				const switchCase = switchCases[index];
+
+				if (switchCase.consequent.length > 0) {
+					const prev = this.prevStatement;
+					this.blockPreWalkStatements(switchCase.consequent);
+					this.prevStatement = prev;
+				}
+			}
+
+			for (let index = 0; index < len; index++) {
+				const switchCase = switchCases[index];
+
+				if (switchCase.test) {
+					this.walkExpression(switchCase.test);
+				}
+				if (switchCase.consequent.length > 0) {
+					this.walkStatements(switchCase.consequent);
+				}
+			}
+		});
+	}
+
+	preWalkCatchClause(catchClause) {
+		this.preWalkStatement(catchClause.body);
+	}
+
+	walkCatchClause(catchClause) {
+		this.inBlockScope(() => {
+			// Error binding is optional in catch clause since ECMAScript 2019
+			if (catchClause.param !== null) {
+				this.enterPattern(catchClause.param, ident => {
+					this.defineVariable(ident);
+				});
+				this.walkPattern(catchClause.param);
+			}
+			const prev = this.prevStatement;
+			this.blockPreWalkStatement(catchClause.body);
+			this.prevStatement = prev;
+			this.walkStatement(catchClause.body);
+		});
+	}
+
+	walkPattern(pattern) {
+		switch (pattern.type) {
+			case "ArrayPattern":
+				this.walkArrayPattern(pattern);
+				break;
+			case "AssignmentPattern":
+				this.walkAssignmentPattern(pattern);
+				break;
+			case "MemberExpression":
+				this.walkMemberExpression(pattern);
+				break;
+			case "ObjectPattern":
+				this.walkObjectPattern(pattern);
+				break;
+			case "RestElement":
+				this.walkRestElement(pattern);
+				break;
+		}
+	}
+
+	walkAssignmentPattern(pattern) {
+		this.walkExpression(pattern.right);
+		this.walkPattern(pattern.left);
+	}
+
+	walkObjectPattern(pattern) {
+		for (let i = 0, len = pattern.properties.length; i < len; i++) {
+			const prop = pattern.properties[i];
+			if (prop) {
+				if (prop.computed) this.walkExpression(prop.key);
+				if (prop.value) this.walkPattern(prop.value);
+			}
+		}
+	}
+
+	walkArrayPattern(pattern) {
+		for (let i = 0, len = pattern.elements.length; i < len; i++) {
+			const element = pattern.elements[i];
+			if (element) this.walkPattern(element);
+		}
+	}
+
+	walkRestElement(pattern) {
+		this.walkPattern(pattern.argument);
+	}
+
+	walkExpressions(expressions) {
+		for (const expression of expressions) {
+			if (expression) {
+				this.walkExpression(expression);
+			}
+		}
+	}
+
+	walkExpression(expression) {
+		switch (expression.type) {
+			case "ArrayExpression":
+				this.walkArrayExpression(expression);
+				break;
+			case "ArrowFunctionExpression":
+				this.walkArrowFunctionExpression(expression);
+				break;
+			case "AssignmentExpression":
+				this.walkAssignmentExpression(expression);
+				break;
+			case "AwaitExpression":
+				this.walkAwaitExpression(expression);
+				break;
+			case "BinaryExpression":
+				this.walkBinaryExpression(expression);
+				break;
+			case "CallExpression":
+				this.walkCallExpression(expression);
+				break;
+			case "ChainExpression":
+				this.walkChainExpression(expression);
+				break;
+			case "ClassExpression":
+				this.walkClassExpression(expression);
+				break;
+			case "ConditionalExpression":
+				this.walkConditionalExpression(expression);
+				break;
+			case "FunctionExpression":
+				this.walkFunctionExpression(expression);
+				break;
+			case "Identifier":
+				this.walkIdentifier(expression);
+				break;
+			case "ImportExpression":
+				this.walkImportExpression(expression);
+				break;
+			case "LogicalExpression":
+				this.walkLogicalExpression(expression);
+				break;
+			case "MetaProperty":
+				this.walkMetaProperty(expression);
+				break;
+			case "MemberExpression":
+				this.walkMemberExpression(expression);
+				break;
+			case "NewExpression":
+				this.walkNewExpression(expression);
+				break;
+			case "ObjectExpression":
+				this.walkObjectExpression(expression);
+				break;
+			case "SequenceExpression":
+				this.walkSequenceExpression(expression);
+				break;
+			case "SpreadElement":
+				this.walkSpreadElement(expression);
+				break;
+			case "TaggedTemplateExpression":
+				this.walkTaggedTemplateExpression(expression);
+				break;
+			case "TemplateLiteral":
+				this.walkTemplateLiteral(expression);
+				break;
+			case "ThisExpression":
+				this.walkThisExpression(expression);
+				break;
+			case "UnaryExpression":
+				this.walkUnaryExpression(expression);
+				break;
+			case "UpdateExpression":
+				this.walkUpdateExpression(expression);
+				break;
+			case "YieldExpression":
+				this.walkYieldExpression(expression);
+				break;
+		}
+	}
+
+	walkAwaitExpression(expression) {
+		if (this.scope.topLevelScope === true)
+			this.hooks.topLevelAwait.call(expression);
+		this.walkExpression(expression.argument);
+	}
+
+	walkArrayExpression(expression) {
+		if (expression.elements) {
+			this.walkExpressions(expression.elements);
+		}
+	}
+
+	walkSpreadElement(expression) {
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
+	}
+
+	walkObjectExpression(expression) {
+		for (
+			let propIndex = 0, len = expression.properties.length;
+			propIndex < len;
+			propIndex++
+		) {
+			const prop = expression.properties[propIndex];
+			this.walkProperty(prop);
+		}
+	}
+
+	walkProperty(prop) {
+		if (prop.type === "SpreadElement") {
+			this.walkExpression(prop.argument);
+			return;
+		}
+		if (prop.computed) {
+			this.walkExpression(prop.key);
+		}
+		if (prop.shorthand && prop.value && prop.value.type === "Identifier") {
+			this.scope.inShorthand = prop.value.name;
+			this.walkIdentifier(prop.value);
+			this.scope.inShorthand = false;
+		} else {
+			this.walkExpression(prop.value);
+		}
+	}
+
+	walkFunctionExpression(expression) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = false;
+		const scopeParams = expression.params;
+
+		// Add function name in scope for recursive calls
+		if (expression.id) {
+			scopeParams.push(expression.id.name);
+		}
+
+		this.inFunctionScope(true, scopeParams, () => {
+			for (const param of expression.params) {
+				this.walkPattern(param);
+			}
+			if (expression.body.type === "BlockStatement") {
+				this.detectMode(expression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(expression.body);
+				this.prevStatement = prev;
+				this.walkStatement(expression.body);
+			} else {
+				this.walkExpression(expression.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
+	}
+
+	walkArrowFunctionExpression(expression) {
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = wasTopLevel ? "arrow" : false;
+		this.inFunctionScope(false, expression.params, () => {
+			for (const param of expression.params) {
+				this.walkPattern(param);
+			}
+			if (expression.body.type === "BlockStatement") {
+				this.detectMode(expression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(expression.body);
+				this.prevStatement = prev;
+				this.walkStatement(expression.body);
+			} else {
+				this.walkExpression(expression.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
+	}
+
+	/**
+	 * @param {SequenceExpressionNode} expression the sequence
+	 */
+	walkSequenceExpression(expression) {
+		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];
+		if (
+			currentStatement === expression ||
+			(currentStatement.type === "ExpressionStatement" &&
+				currentStatement.expression === expression)
+		) {
+			const old = this.statementPath.pop();
+			for (const expr of expression.expressions) {
+				this.statementPath.push(expr);
+				this.walkExpression(expr);
+				this.statementPath.pop();
+			}
+			this.statementPath.push(old);
+		} else {
+			this.walkExpressions(expression.expressions);
+		}
+	}
+
+	walkUpdateExpression(expression) {
+		this.walkExpression(expression.argument);
+	}
+
+	walkUnaryExpression(expression) {
+		if (expression.operator === "typeof") {
+			const result = this.callHooksForExpression(
+				this.hooks.typeof,
+				expression.argument,
+				expression
+			);
+			if (result === true) return;
+			if (expression.argument.type === "ChainExpression") {
+				const result = this.callHooksForExpression(
+					this.hooks.typeof,
+					expression.argument.expression,
+					expression
+				);
+				if (result === true) return;
+			}
+		}
+		this.walkExpression(expression.argument);
+	}
+
+	walkLeftRightExpression(expression) {
+		this.walkExpression(expression.left);
+		this.walkExpression(expression.right);
+	}
+
+	walkBinaryExpression(expression) {
+		this.walkLeftRightExpression(expression);
+	}
+
+	walkLogicalExpression(expression) {
+		const result = this.hooks.expressionLogicalOperator.call(expression);
+		if (result === undefined) {
+			this.walkLeftRightExpression(expression);
+		} else {
+			if (result) {
+				this.walkExpression(expression.right);
+			}
+		}
+	}
+
+	walkAssignmentExpression(expression) {
+		if (expression.left.type === "Identifier") {
+			const renameIdentifier = this.getRenameIdentifier(expression.right);
+			if (renameIdentifier) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.canRename,
+						renameIdentifier,
+						expression.right
+					)
+				) {
+					// renaming "a = b;"
+					if (
+						!this.callHooksForInfo(
+							this.hooks.rename,
+							renameIdentifier,
+							expression.right
+						)
+					) {
+						this.setVariable(
+							expression.left.name,
+							this.getVariableInfo(renameIdentifier)
+						);
+					}
+					return;
+				}
+			}
+			this.walkExpression(expression.right);
+			this.enterPattern(expression.left, (name, decl) => {
+				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
+					this.walkExpression(expression.left);
+				}
+			});
+			return;
+		}
+		if (expression.left.type.endsWith("Pattern")) {
+			this.walkExpression(expression.right);
+			this.enterPattern(expression.left, (name, decl) => {
+				if (!this.callHooksForName(this.hooks.assign, name, expression)) {
+					this.defineVariable(name);
+				}
+			});
+			this.walkPattern(expression.left);
+		} else if (expression.left.type === "MemberExpression") {
+			const exprName = this.getMemberExpressionInfo(
+				expression.left,
+				ALLOWED_MEMBER_TYPES_EXPRESSION
+			);
+			if (exprName) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.assignMemberChain,
+						exprName.rootInfo,
+						expression,
+						exprName.getMembers()
+					)
+				) {
+					return;
+				}
+			}
+			this.walkExpression(expression.right);
+			this.walkExpression(expression.left);
+		} else {
+			this.walkExpression(expression.right);
+			this.walkExpression(expression.left);
+		}
+	}
+
+	walkConditionalExpression(expression) {
+		const result = this.hooks.expressionConditionalOperator.call(expression);
+		if (result === undefined) {
+			this.walkExpression(expression.test);
+			this.walkExpression(expression.consequent);
+			if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
+		} else {
+			if (result) {
+				this.walkExpression(expression.consequent);
+			} else if (expression.alternate) {
+				this.walkExpression(expression.alternate);
+			}
+		}
+	}
+
+	walkNewExpression(expression) {
+		const result = this.callHooksForExpression(
+			this.hooks.new,
+			expression.callee,
+			expression
+		);
+		if (result === true) return;
+		this.walkExpression(expression.callee);
+		if (expression.arguments) {
+			this.walkExpressions(expression.arguments);
+		}
+	}
+
+	walkYieldExpression(expression) {
+		if (expression.argument) {
+			this.walkExpression(expression.argument);
+		}
+	}
+
+	walkTemplateLiteral(expression) {
+		if (expression.expressions) {
+			this.walkExpressions(expression.expressions);
+		}
+	}
+
+	walkTaggedTemplateExpression(expression) {
+		if (expression.tag) {
+			this.walkExpression(expression.tag);
+		}
+		if (expression.quasi && expression.quasi.expressions) {
+			this.walkExpressions(expression.quasi.expressions);
+		}
+	}
+
+	walkClassExpression(expression) {
+		this.walkClass(expression);
+	}
+
+	/**
+	 * @param {ChainExpressionNode} expression expression
+	 */
+	walkChainExpression(expression) {
+		const result = this.hooks.optionalChaining.call(expression);
+
+		if (result === undefined) {
+			if (expression.expression.type === "CallExpression") {
+				this.walkCallExpression(expression.expression);
+			} else {
+				this.walkMemberExpression(expression.expression);
+			}
+		}
+	}
+
+	_walkIIFE(functionExpression, options, currentThis) {
+		const getVarInfo = argOrThis => {
+			const renameIdentifier = this.getRenameIdentifier(argOrThis);
+			if (renameIdentifier) {
+				if (
+					this.callHooksForInfo(
+						this.hooks.canRename,
+						renameIdentifier,
+						argOrThis
+					)
+				) {
+					if (
+						!this.callHooksForInfo(
+							this.hooks.rename,
+							renameIdentifier,
+							argOrThis
+						)
+					) {
+						return this.getVariableInfo(renameIdentifier);
+					}
+				}
+			}
+			this.walkExpression(argOrThis);
+		};
+		const { params, type } = functionExpression;
+		const arrow = type === "ArrowFunctionExpression";
+		const renameThis = currentThis ? getVarInfo(currentThis) : null;
+		const varInfoForArgs = options.map(getVarInfo);
+		const wasTopLevel = this.scope.topLevelScope;
+		this.scope.topLevelScope = wasTopLevel && arrow ? "arrow" : false;
+		const scopeParams = params.filter(
+			(identifier, idx) => !varInfoForArgs[idx]
+		);
+
+		// Add function name in scope for recursive calls
+		if (functionExpression.id) {
+			scopeParams.push(functionExpression.id.name);
+		}
+
+		this.inFunctionScope(true, scopeParams, () => {
+			if (renameThis && !arrow) {
+				this.setVariable("this", renameThis);
+			}
+			for (let i = 0; i < varInfoForArgs.length; i++) {
+				const varInfo = varInfoForArgs[i];
+				if (!varInfo) continue;
+				if (!params[i] || params[i].type !== "Identifier") continue;
+				this.setVariable(params[i].name, varInfo);
+			}
+			if (functionExpression.body.type === "BlockStatement") {
+				this.detectMode(functionExpression.body.body);
+				const prev = this.prevStatement;
+				this.preWalkStatement(functionExpression.body);
+				this.prevStatement = prev;
+				this.walkStatement(functionExpression.body);
+			} else {
+				this.walkExpression(functionExpression.body);
+			}
+		});
+		this.scope.topLevelScope = wasTopLevel;
+	}
+
+	walkImportExpression(expression) {
+		let result = this.hooks.importCall.call(expression);
+		if (result === true) return;
+
+		this.walkExpression(expression.source);
+	}
+
+	walkCallExpression(expression) {
+		const isSimpleFunction = fn => {
+			return fn.params.every(p => p.type === "Identifier");
+		};
+		if (
+			expression.callee.type === "MemberExpression" &&
+			expression.callee.object.type.endsWith("FunctionExpression") &&
+			!expression.callee.computed &&
+			(expression.callee.property.name === "call" ||
+				expression.callee.property.name === "bind") &&
+			expression.arguments.length > 0 &&
+			isSimpleFunction(expression.callee.object)
+		) {
+			// (function(…) { }.call/bind(?, …))
+			this._walkIIFE(
+				expression.callee.object,
+				expression.arguments.slice(1),
+				expression.arguments[0]
+			);
+		} else if (
+			expression.callee.type.endsWith("FunctionExpression") &&
+			isSimpleFunction(expression.callee)
+		) {
+			// (function(…) { }(…))
+			this._walkIIFE(expression.callee, expression.arguments, null);
+		} else {
+			if (expression.callee.type === "MemberExpression") {
+				const exprInfo = this.getMemberExpressionInfo(
+					expression.callee,
+					ALLOWED_MEMBER_TYPES_CALL_EXPRESSION
+				);
+				if (exprInfo && exprInfo.type === "call") {
+					const result = this.callHooksForInfo(
+						this.hooks.callMemberChainOfCallMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						exprInfo.getCalleeMembers(),
+						exprInfo.call,
+						exprInfo.getMembers()
+					);
+					if (result === true) return;
+				}
+			}
+			const callee = this.evaluateExpression(expression.callee);
+			if (callee.isIdentifier()) {
+				const result1 = this.callHooksForInfo(
+					this.hooks.callMemberChain,
+					callee.rootInfo,
+					expression,
+					callee.getMembers()
+				);
+				if (result1 === true) return;
+				const result2 = this.callHooksForInfo(
+					this.hooks.call,
+					callee.identifier,
+					expression
+				);
+				if (result2 === true) return;
+			}
+
+			if (expression.callee) {
+				if (expression.callee.type === "MemberExpression") {
+					// because of call context we need to walk the call context as expression
+					this.walkExpression(expression.callee.object);
+					if (expression.callee.computed === true)
+						this.walkExpression(expression.callee.property);
+				} else {
+					this.walkExpression(expression.callee);
+				}
+			}
+			if (expression.arguments) this.walkExpressions(expression.arguments);
+		}
+	}
+
+	walkMemberExpression(expression) {
+		const exprInfo = this.getMemberExpressionInfo(
+			expression,
+			ALLOWED_MEMBER_TYPES_ALL
+		);
+		if (exprInfo) {
+			switch (exprInfo.type) {
+				case "expression": {
+					const result1 = this.callHooksForInfo(
+						this.hooks.expression,
+						exprInfo.name,
+						expression
+					);
+					if (result1 === true) return;
+					const members = exprInfo.getMembers();
+					const result2 = this.callHooksForInfo(
+						this.hooks.expressionMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						members
+					);
+					if (result2 === true) return;
+					this.walkMemberExpressionWithExpressionName(
+						expression,
+						exprInfo.name,
+						exprInfo.rootInfo,
+						members.slice(),
+						() =>
+							this.callHooksForInfo(
+								this.hooks.unhandledExpressionMemberChain,
+								exprInfo.rootInfo,
+								expression,
+								members
+							)
+					);
+					return;
+				}
+				case "call": {
+					const result = this.callHooksForInfo(
+						this.hooks.memberChainOfCallMemberChain,
+						exprInfo.rootInfo,
+						expression,
+						exprInfo.getCalleeMembers(),
+						exprInfo.call,
+						exprInfo.getMembers()
+					);
+					if (result === true) return;
+					// Fast skip over the member chain as we already called memberChainOfCallMemberChain
+					// and call computed property are literals anyway
+					this.walkExpression(exprInfo.call);
+					return;
+				}
+			}
+		}
+		this.walkExpression(expression.object);
+		if (expression.computed === true) this.walkExpression(expression.property);
+	}
+
+	walkMemberExpressionWithExpressionName(
+		expression,
+		name,
+		rootInfo,
+		members,
+		onUnhandled
+	) {
+		if (expression.object.type === "MemberExpression") {
+			// optimize the case where expression.object is a MemberExpression too.
+			// we can keep info here when calling walkMemberExpression directly
+			const property =
+				expression.property.name || `${expression.property.value}`;
+			name = name.slice(0, -property.length - 1);
+			members.pop();
+			const result = this.callHooksForInfo(
+				this.hooks.expression,
+				name,
+				expression.object
+			);
+			if (result === true) return;
+			this.walkMemberExpressionWithExpressionName(
+				expression.object,
+				name,
+				rootInfo,
+				members,
+				onUnhandled
+			);
+		} else if (!onUnhandled || !onUnhandled()) {
+			this.walkExpression(expression.object);
+		}
+		if (expression.computed === true) this.walkExpression(expression.property);
+	}
+
+	walkThisExpression(expression) {
+		this.callHooksForName(this.hooks.expression, "this", expression);
+	}
+
+	walkIdentifier(expression) {
+		this.callHooksForName(this.hooks.expression, expression.name, expression);
+	}
+
+	/**
+	 * @param {MetaPropertyNode} metaProperty meta property
+	 */
+	walkMetaProperty(metaProperty) {
+		this.hooks.expression.for(getRootName(metaProperty)).call(metaProperty);
+	}
+
+	callHooksForExpression(hookMap, expr, ...args) {
+		return this.callHooksForExpressionWithFallback(
+			hookMap,
+			expr,
+			undefined,
+			undefined,
+			...args
+		);
+	}
+
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {MemberExpressionNode} expr expression info
+	 * @param {function(string, string | ScopeInfo | VariableInfo, function(): string[]): any} fallback callback when variable in not handled by hooks
+	 * @param {function(string): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForExpressionWithFallback(
+		hookMap,
+		expr,
+		fallback,
+		defined,
+		...args
+	) {
+		const exprName = this.getMemberExpressionInfo(
+			expr,
+			ALLOWED_MEMBER_TYPES_EXPRESSION
+		);
+		if (exprName !== undefined) {
+			const members = exprName.getMembers();
+			return this.callHooksForInfoWithFallback(
+				hookMap,
+				members.length === 0 ? exprName.rootInfo : exprName.name,
+				fallback &&
+					(name => fallback(name, exprName.rootInfo, exprName.getMembers)),
+				defined && (() => defined(exprName.name)),
+				...args
+			);
+		}
+	}
+
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {string} name key in map
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForName(hookMap, name, ...args) {
+		return this.callHooksForNameWithFallback(
+			hookMap,
+			name,
+			undefined,
+			undefined,
+			...args
+		);
+	}
+
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param  {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForInfo(hookMap, info, ...args) {
+		return this.callHooksForInfoWithFallback(
+			hookMap,
+			info,
+			undefined,
+			undefined,
+			...args
+		);
+	}
+
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {ExportedVariableInfo} info variable info
+	 * @param {function(string): any} fallback callback when variable in not handled by hooks
+	 * @param {function(): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForInfoWithFallback(hookMap, info, fallback, defined, ...args) {
+		let name;
+		if (typeof info === "string") {
+			name = info;
+		} else {
+			if (!(info instanceof VariableInfo)) {
+				if (defined !== undefined) {
+					return defined();
+				}
+				return;
+			}
+			let tagInfo = info.tagInfo;
+			while (tagInfo !== undefined) {
+				const hook = hookMap.get(tagInfo.tag);
+				if (hook !== undefined) {
+					this.currentTagData = tagInfo.data;
+					const result = hook.call(...args);
+					this.currentTagData = undefined;
+					if (result !== undefined) return result;
+				}
+				tagInfo = tagInfo.next;
+			}
+			if (info.freeName === true) {
+				if (defined !== undefined) {
+					return defined();
+				}
+				return;
+			}
+			name = info.freeName;
+		}
+		const hook = hookMap.get(name);
+		if (hook !== undefined) {
+			const result = hook.call(...args);
+			if (result !== undefined) return result;
+		}
+		if (fallback !== undefined) {
+			return fallback(name);
+		}
+	}
+
+	/**
+	 * @template T
+	 * @template R
+	 * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+	 * @param {string} name key in map
+	 * @param {function(string): any} fallback callback when variable in not handled by hooks
+	 * @param {function(): any} defined callback when variable is defined
+	 * @param {AsArray<T>} args args for the hook
+	 * @returns {R} result of hook
+	 */
+	callHooksForNameWithFallback(hookMap, name, fallback, defined, ...args) {
+		return this.callHooksForInfoWithFallback(
+			hookMap,
+			this.getVariableInfo(name),
+			fallback,
+			defined,
+			...args
+		);
+	}
+
+	/**
+	 * @deprecated
+	 * @param {any} params scope params
+	 * @param {function(): void} fn inner function
+	 * @returns {void}
+	 */
+	inScope(params, fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
+
+		this.undefineVariable("this");
+
+		this.enterPatterns(params, (ident, pattern) => {
+			this.defineVariable(ident);
+		});
+
+		fn();
+
+		this.scope = oldScope;
+	}
+
+	inFunctionScope(hasThis, params, fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: false,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
+
+		if (hasThis) {
+			this.undefineVariable("this");
+		}
+
+		this.enterPatterns(params, (ident, pattern) => {
+			this.defineVariable(ident);
+		});
+
+		fn();
+
+		this.scope = oldScope;
+	}
+
+	inBlockScope(fn) {
+		const oldScope = this.scope;
+		this.scope = {
+			topLevelScope: oldScope.topLevelScope,
+			inTry: oldScope.inTry,
+			inShorthand: false,
+			isStrict: oldScope.isStrict,
+			isAsmJs: oldScope.isAsmJs,
+			definitions: oldScope.definitions.createChild()
+		};
+
+		fn();
+
+		this.scope = oldScope;
+	}
+
+	detectMode(statements) {
+		const isLiteral =
+			statements.length >= 1 &&
+			statements[0].type === "ExpressionStatement" &&
+			statements[0].expression.type === "Literal";
+		if (isLiteral && statements[0].expression.value === "use strict") {
+			this.scope.isStrict = true;
+		}
+		if (isLiteral && statements[0].expression.value === "use asm") {
+			this.scope.isAsmJs = true;
+		}
+	}
+
+	enterPatterns(patterns, onIdent) {
+		for (const pattern of patterns) {
+			if (typeof pattern !== "string") {
+				this.enterPattern(pattern, onIdent);
+			} else if (pattern) {
+				onIdent(pattern);
+			}
+		}
+	}
+
+	enterPattern(pattern, onIdent) {
+		if (!pattern) return;
+		switch (pattern.type) {
+			case "ArrayPattern":
+				this.enterArrayPattern(pattern, onIdent);
+				break;
+			case "AssignmentPattern":
+				this.enterAssignmentPattern(pattern, onIdent);
+				break;
+			case "Identifier":
+				this.enterIdentifier(pattern, onIdent);
+				break;
+			case "ObjectPattern":
+				this.enterObjectPattern(pattern, onIdent);
+				break;
+			case "RestElement":
+				this.enterRestElement(pattern, onIdent);
+				break;
+			case "Property":
+				if (pattern.shorthand && pattern.value.type === "Identifier") {
+					this.scope.inShorthand = pattern.value.name;
+					this.enterIdentifier(pattern.value, onIdent);
+					this.scope.inShorthand = false;
+				} else {
+					this.enterPattern(pattern.value, onIdent);
+				}
+				break;
+		}
+	}
+
+	enterIdentifier(pattern, onIdent) {
+		if (!this.callHooksForName(this.hooks.pattern, pattern.name, pattern)) {
+			onIdent(pattern.name, pattern);
+		}
+	}
+
+	enterObjectPattern(pattern, onIdent) {
+		for (
+			let propIndex = 0, len = pattern.properties.length;
+			propIndex < len;
+			propIndex++
+		) {
+			const prop = pattern.properties[propIndex];
+			this.enterPattern(prop, onIdent);
+		}
+	}
+
+	enterArrayPattern(pattern, onIdent) {
+		for (
+			let elementIndex = 0, len = pattern.elements.length;
+			elementIndex < len;
+			elementIndex++
+		) {
+			const element = pattern.elements[elementIndex];
+			this.enterPattern(element, onIdent);
+		}
+	}
+
+	enterRestElement(pattern, onIdent) {
+		this.enterPattern(pattern.argument, onIdent);
+	}
+
+	enterAssignmentPattern(pattern, onIdent) {
+		this.enterPattern(pattern.left, onIdent);
+	}
+
+	/**
+	 * @param {ExpressionNode} expression expression node
+	 * @returns {BasicEvaluatedExpression | undefined} evaluation result
+	 */
+	evaluateExpression(expression) {
+		try {
+			const hook = this.hooks.evaluate.get(expression.type);
+			if (hook !== undefined) {
+				const result = hook.call(expression);
+				if (result !== undefined) {
+					if (result) {
+						result.setExpression(expression);
+					}
+					return result;
+				}
+			}
+		} catch (e) {
+			console.warn(e);
+			// ignore error
+		}
+		return new BasicEvaluatedExpression()
+			.setRange(expression.range)
+			.setExpression(expression);
+	}
+
+	parseString(expression) {
+		switch (expression.type) {
+			case "BinaryExpression":
+				if (expression.operator === "+") {
+					return (
+						this.parseString(expression.left) +
+						this.parseString(expression.right)
+					);
+				}
+				break;
+			case "Literal":
+				return expression.value + "";
+		}
+		throw new Error(
+			expression.type + " is not supported as parameter for require"
+		);
+	}
+
+	parseCalculatedString(expression) {
+		switch (expression.type) {
+			case "BinaryExpression":
+				if (expression.operator === "+") {
+					const left = this.parseCalculatedString(expression.left);
+					const right = this.parseCalculatedString(expression.right);
+					if (left.code) {
+						return {
+							range: left.range,
+							value: left.value,
+							code: true,
+							conditional: false
+						};
+					} else if (right.code) {
+						return {
+							range: [
+								left.range[0],
+								right.range ? right.range[1] : left.range[1]
+							],
+							value: left.value + right.value,
+							code: true,
+							conditional: false
+						};
+					} else {
+						return {
+							range: [left.range[0], right.range[1]],
+							value: left.value + right.value,
+							code: false,
+							conditional: false
+						};
+					}
+				}
+				break;
+			case "ConditionalExpression": {
+				const consequent = this.parseCalculatedString(expression.consequent);
+				const alternate = this.parseCalculatedString(expression.alternate);
+				const items = [];
+				if (consequent.conditional) {
+					items.push(...consequent.conditional);
+				} else if (!consequent.code) {
+					items.push(consequent);
+				} else {
+					break;
+				}
+				if (alternate.conditional) {
+					items.push(...alternate.conditional);
+				} else if (!alternate.code) {
+					items.push(alternate);
+				} else {
+					break;
+				}
+				return {
+					range: undefined,
+					value: "",
+					code: true,
+					conditional: items
+				};
+			}
+			case "Literal":
+				return {
+					range: expression.range,
+					value: expression.value + "",
+					code: false,
+					conditional: false
+				};
+		}
+		return {
+			range: undefined,
+			value: "",
+			code: true,
+			conditional: false
+		};
+	}
+
+	/**
+	 * @param {string | Buffer | PreparsedAst} source the source to parse
+	 * @param {ParserState} state the parser state
+	 * @returns {ParserState} the parser state
+	 */
+	parse(source, state) {
+		let ast;
+		let comments;
+		const semicolons = new Set();
+		if (source === null) {
+			throw new Error("source must not be null");
+		}
+		if (Buffer.isBuffer(source)) {
+			source = source.toString("utf-8");
+		}
+		if (typeof source === "object") {
+			ast = /** @type {ProgramNode} */ (source);
+			comments = source.comments;
+		} else {
+			comments = [];
+			ast = JavascriptParser._parse(source, {
+				sourceType: this.sourceType,
+				onComment: comments,
+				onInsertedSemicolon: pos => semicolons.add(pos)
+			});
+		}
+
+		const oldScope = this.scope;
+		const oldState = this.state;
+		const oldComments = this.comments;
+		const oldSemicolons = this.semicolons;
+		const oldStatementPath = this.statementPath;
+		const oldPrevStatement = this.prevStatement;
+		this.scope = {
+			topLevelScope: true,
+			inTry: false,
+			inShorthand: false,
+			isStrict: false,
+			isAsmJs: false,
+			definitions: new StackedMap()
+		};
+		/** @type {ParserState} */
+		this.state = state;
+		this.comments = comments;
+		this.semicolons = semicolons;
+		this.statementPath = [];
+		this.prevStatement = undefined;
+		if (this.hooks.program.call(ast, comments) === undefined) {
+			this.detectMode(ast.body);
+			this.preWalkStatements(ast.body);
+			this.prevStatement = undefined;
+			this.blockPreWalkStatements(ast.body);
+			this.prevStatement = undefined;
+			this.walkStatements(ast.body);
+		}
+		this.hooks.finish.call(ast, comments);
+		this.scope = oldScope;
+		/** @type {ParserState} */
+		this.state = oldState;
+		this.comments = oldComments;
+		this.semicolons = oldSemicolons;
+		this.statementPath = oldStatementPath;
+		this.prevStatement = oldPrevStatement;
+		return state;
+	}
+
+	evaluate(source) {
+		const ast = JavascriptParser._parse("(" + source + ")", {
+			sourceType: this.sourceType,
+			locations: false
+		});
+		if (ast.body.length !== 1 || ast.body[0].type !== "ExpressionStatement") {
+			throw new Error("evaluate: Source is not a expression");
+		}
+		return this.evaluateExpression(ast.body[0].expression);
+	}
+
+	/**
+	 * @param {ExpressionNode | DeclarationNode | PrivateIdentifierNode | null | undefined} expr an expression
+	 * @param {number} commentsStartPos source position from which annotation comments are checked
+	 * @returns {boolean} true, when the expression is pure
+	 */
+	isPure(expr, commentsStartPos) {
+		if (!expr) return true;
+		const result = this.hooks.isPure
+			.for(expr.type)
+			.call(expr, commentsStartPos);
+		if (typeof result === "boolean") return result;
+		switch (expr.type) {
+			case "ClassDeclaration":
+			case "ClassExpression": {
+				if (expr.body.type !== "ClassBody") return false;
+				if (expr.superClass && !this.isPure(expr.superClass, expr.range[0])) {
+					return false;
+				}
+				const items =
+					/** @type {(MethodDefinitionNode | PropertyDefinitionNode)[]} */ (
+						expr.body.body
+					);
+				return items.every(
+					item =>
+						(!item.computed ||
+							!item.key ||
+							this.isPure(item.key, item.range[0])) &&
+						(!item.static ||
+							!item.value ||
+							this.isPure(
+								item.value,
+								item.key ? item.key.range[1] : item.range[0]
+							))
+				);
+			}
+
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+			case "Literal":
+			case "PrivateIdentifier":
+				return true;
+
+			case "VariableDeclaration":
+				return expr.declarations.every(decl =>
+					this.isPure(decl.init, decl.range[0])
+				);
+
+			case "ConditionalExpression":
+				return (
+					this.isPure(expr.test, commentsStartPos) &&
+					this.isPure(expr.consequent, expr.test.range[1]) &&
+					this.isPure(expr.alternate, expr.consequent.range[1])
+				);
+
+			case "SequenceExpression":
+				return expr.expressions.every(expr => {
+					const pureFlag = this.isPure(expr, commentsStartPos);
+					commentsStartPos = expr.range[1];
+					return pureFlag;
+				});
+
+			case "CallExpression": {
+				const pureFlag =
+					expr.range[0] - commentsStartPos > 12 &&
+					this.getComments([commentsStartPos, expr.range[0]]).some(
+						comment =>
+							comment.type === "Block" &&
+							/^\s*(#|@)__PURE__\s*$/.test(comment.value)
+					);
+				if (!pureFlag) return false;
+				commentsStartPos = expr.callee.range[1];
+				return expr.arguments.every(arg => {
+					if (arg.type === "SpreadElement") return false;
+					const pureFlag = this.isPure(arg, commentsStartPos);
+					commentsStartPos = arg.range[1];
+					return pureFlag;
+				});
+			}
+		}
+		const evaluated = this.evaluateExpression(expr);
+		return !evaluated.couldHaveSideEffects();
+	}
+
+	getComments(range) {
+		const [rangeStart, rangeEnd] = range;
+		const compare = (comment, needle) => comment.range[0] - needle;
+		let idx = binarySearchBounds.ge(this.comments, rangeStart, compare);
+		let commentsInRange = [];
+		while (this.comments[idx] && this.comments[idx].range[1] <= rangeEnd) {
+			commentsInRange.push(this.comments[idx]);
+			idx++;
+		}
+
+		return commentsInRange;
+	}
+
+	/**
+	 * @param {number} pos source code position
+	 * @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];
+		if (currentStatement === undefined) throw new Error("Not in statement");
+		return (
+			// Either asking directly for the end position of the current statement
+			(currentStatement.range[1] === pos && 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 &&
+				// is there a previous statement which might be relevant?
+				this.prevStatement !== undefined &&
+				// is the end position of the previous statement an ASI position?
+				this.semicolons.has(this.prevStatement.range[1]))
+		);
+	}
+
+	/**
+	 * @param {number} pos source code position
+	 * @returns {void}
+	 */
+	unsetAsiPosition(pos) {
+		this.semicolons.delete(pos);
+	}
+
+	isStatementLevelExpression(expr) {
+		const currentStatement = this.statementPath[this.statementPath.length - 1];
+		return (
+			expr === currentStatement ||
+			(currentStatement.type === "ExpressionStatement" &&
+				currentStatement.expression === expr)
+		);
+	}
+
+	getTagData(name, tag) {
+		const info = this.scope.definitions.get(name);
+		if (info instanceof VariableInfo) {
+			let tagInfo = info.tagInfo;
+			while (tagInfo !== undefined) {
+				if (tagInfo.tag === tag) return tagInfo.data;
+				tagInfo = tagInfo.next;
+			}
+		}
+	}
+
+	tagVariable(name, tag, data) {
+		const oldInfo = this.scope.definitions.get(name);
+		/** @type {VariableInfo} */
+		let newInfo;
+		if (oldInfo === undefined) {
+			newInfo = new VariableInfo(this.scope, name, {
+				tag,
+				data,
+				next: undefined
+			});
+		} else if (oldInfo instanceof VariableInfo) {
+			newInfo = new VariableInfo(oldInfo.declaredScope, oldInfo.freeName, {
+				tag,
+				data,
+				next: oldInfo.tagInfo
+			});
+		} else {
+			newInfo = new VariableInfo(oldInfo, true, {
+				tag,
+				data,
+				next: undefined
+			});
+		}
+		this.scope.definitions.set(name, newInfo);
+	}
+
+	defineVariable(name) {
+		const oldInfo = this.scope.definitions.get(name);
+		// Don't redefine variable in same scope to keep existing tags
+		if (oldInfo instanceof VariableInfo && oldInfo.declaredScope === this.scope)
+			return;
+		this.scope.definitions.set(name, this.scope);
+	}
+
+	undefineVariable(name) {
+		this.scope.definitions.delete(name);
+	}
+
+	isVariableDefined(name) {
+		const info = this.scope.definitions.get(name);
+		if (info === undefined) return false;
+		if (info instanceof VariableInfo) {
+			return info.freeName === true;
+		}
+		return true;
+	}
+
+	/**
+	 * @param {string} name variable name
+	 * @returns {ExportedVariableInfo} info for this variable
+	 */
+	getVariableInfo(name) {
+		const value = this.scope.definitions.get(name);
+		if (value === undefined) {
+			return name;
+		} else {
+			return value;
+		}
+	}
+
+	/**
+	 * @param {string} name variable name
+	 * @param {ExportedVariableInfo} variableInfo new info for this variable
+	 * @returns {void}
+	 */
+	setVariable(name, variableInfo) {
+		if (typeof variableInfo === "string") {
+			if (variableInfo === name) {
+				this.scope.definitions.delete(name);
+			} else {
+				this.scope.definitions.set(
+					name,
+					new VariableInfo(this.scope, variableInfo, undefined)
+				);
+			}
+		} else {
+			this.scope.definitions.set(name, variableInfo);
+		}
+	}
+
+	parseCommentOptions(range) {
+		const comments = this.getComments(range);
+		if (comments.length === 0) {
+			return EMPTY_COMMENT_OPTIONS;
+		}
+		let options = {};
+		let errors = [];
+		for (const comment of comments) {
+			const { value } = comment;
+			if (value && webpackCommentRegExp.test(value)) {
+				// try compile only if webpack options comment is present
+				try {
+					const val = vm.runInNewContext(`(function(){return {${value}};})()`);
+					Object.assign(options, val);
+				} catch (e) {
+					e.comment = comment;
+					errors.push(e);
+				}
+			}
+		}
+		return { options, errors };
+	}
+
+	/**
+	 * @param {MemberExpressionNode} expression a member expression
+	 * @returns {{ members: string[], object: ExpressionNode | SuperNode }} member names (reverse order) and remaining object
+	 */
+	extractMemberExpressionChain(expression) {
+		/** @type {AnyNode} */
+		let expr = expression;
+		const members = [];
+		while (expr.type === "MemberExpression") {
+			if (expr.computed) {
+				if (expr.property.type !== "Literal") break;
+				members.push(`${expr.property.value}`);
+			} else {
+				if (expr.property.type !== "Identifier") break;
+				members.push(expr.property.name);
+			}
+			expr = expr.object;
+		}
+		return {
+			members,
+			object: expr
+		};
+	}
+
+	/**
+	 * @param {string} varName variable name
+	 * @returns {{name: string, info: VariableInfo | string}} name of the free variable and variable info for that
+	 */
+	getFreeInfoFromVariable(varName) {
+		const info = this.getVariableInfo(varName);
+		let name;
+		if (info instanceof VariableInfo) {
+			name = info.freeName;
+			if (typeof name !== "string") return undefined;
+		} else if (typeof info !== "string") {
+			return undefined;
+		} else {
+			name = info;
+		}
+		return { info, name };
+	}
+
+	/** @typedef {{ type: "call", call: CallExpressionNode, calleeName: string, rootInfo: string | VariableInfo, getCalleeMembers: () => string[], name: string, getMembers: () => string[]}} CallExpressionInfo */
+	/** @typedef {{ type: "expression", rootInfo: string | VariableInfo, name: string, getMembers: () => string[]}} ExpressionExpressionInfo */
+
+	/**
+	 * @param {MemberExpressionNode} expression a member expression
+	 * @param {number} allowedTypes which types should be returned, presented in bit mask
+	 * @returns {CallExpressionInfo | ExpressionExpressionInfo | undefined} expression info
+	 */
+	getMemberExpressionInfo(expression, allowedTypes) {
+		const { object, members } = this.extractMemberExpressionChain(expression);
+		switch (object.type) {
+			case "CallExpression": {
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_CALL_EXPRESSION) === 0)
+					return undefined;
+				let callee = object.callee;
+				let rootMembers = EMPTY_ARRAY;
+				if (callee.type === "MemberExpression") {
+					({ object: callee, members: rootMembers } =
+						this.extractMemberExpressionChain(callee));
+				}
+				const rootName = getRootName(callee);
+				if (!rootName) return undefined;
+				const result = this.getFreeInfoFromVariable(rootName);
+				if (!result) return undefined;
+				const { info: rootInfo, name: resolvedRoot } = result;
+				const calleeName = objectAndMembersToName(resolvedRoot, rootMembers);
+				return {
+					type: "call",
+					call: object,
+					calleeName,
+					rootInfo,
+					getCalleeMembers: memoize(() => rootMembers.reverse()),
+					name: objectAndMembersToName(`${calleeName}()`, members),
+					getMembers: memoize(() => members.reverse())
+				};
+			}
+			case "Identifier":
+			case "MetaProperty":
+			case "ThisExpression": {
+				if ((allowedTypes & ALLOWED_MEMBER_TYPES_EXPRESSION) === 0)
+					return undefined;
+				const rootName = getRootName(object);
+				if (!rootName) return undefined;
+
+				const result = this.getFreeInfoFromVariable(rootName);
+				if (!result) return undefined;
+				const { info: rootInfo, name: resolvedRoot } = result;
+				return {
+					type: "expression",
+					name: objectAndMembersToName(resolvedRoot, members),
+					rootInfo,
+					getMembers: memoize(() => members.reverse())
+				};
+			}
+		}
+	}
+
+	/**
+	 * @param {MemberExpressionNode} expression an expression
+	 * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]}} name info
+	 */
+	getNameForExpression(expression) {
+		return this.getMemberExpressionInfo(
+			expression,
+			ALLOWED_MEMBER_TYPES_EXPRESSION
+		);
+	}
+
+	/**
+	 * @param {string} code source code
+	 * @param {ParseOptions} options parsing options
+	 * @returns {ProgramNode} parsed ast
+	 */
+	static _parse(code, options) {
+		const type = options ? options.sourceType : "module";
+		/** @type {AcornOptions} */
+		const parserOptions = {
+			...defaultParserOptions,
+			allowReturnOutsideFunction: type === "script",
+			...options,
+			sourceType: type === "auto" ? "module" : type
+		};
+
+		/** @type {AnyNode} */
+		let ast;
+		let error;
+		let threw = false;
+		try {
+			ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
+		} catch (e) {
+			error = e;
+			threw = true;
+		}
+
+		if (threw && type === "auto") {
+			parserOptions.sourceType = "script";
+			if (!("allowReturnOutsideFunction" in options)) {
+				parserOptions.allowReturnOutsideFunction = true;
+			}
+			if (Array.isArray(parserOptions.onComment)) {
+				parserOptions.onComment.length = 0;
+			}
+			try {
+				ast = /** @type {AnyNode} */ (parser.parse(code, parserOptions));
+				threw = false;
+			} catch (e) {
+				// we use the error from first parse try
+				// so nothing to do here
+			}
+		}
+
+		if (threw) {
+			throw error;
+		}
+
+		return /** @type {ProgramNode} */ (ast);
+	}
+}
+
+module.exports = JavascriptParser;
+module.exports.ALLOWED_MEMBER_TYPES_ALL = ALLOWED_MEMBER_TYPES_ALL;
+module.exports.ALLOWED_MEMBER_TYPES_EXPRESSION =
+	ALLOWED_MEMBER_TYPES_EXPRESSION;
+module.exports.ALLOWED_MEMBER_TYPES_CALL_EXPRESSION =
+	ALLOWED_MEMBER_TYPES_CALL_EXPRESSION;