@depup/webpack 5.111.1-depup.2 → 5.112.0-depup.0

package/lib/javascript/ScopeAnalyzer.js

@@ -5,12 +5,15 @@
 
 "use strict";
 
+// cspell:ignore defun, fnames, funarg
+
 /**
  * @import {
  * 	Function as ESTreeFunction,
  * 	Identifier,
  * 	Node,
- * 	Program
+ * 	Program,
+ * 	Property
  * } from "estree"
  */
 
@@ -116,7 +119,7 @@ const CHILD_KEYS = {
 class Scope {
 	/**
 	 * @param {ScopeType} type what opened this scope
-	 * @param {Node} block the node that opened this scope
+	 * @param {Node} block the node that opened this scope, read but not kept
 	 * @param {Scope | null} upper the enclosing scope
 	 * @param {boolean} isVarScope whether `var` and function declarations hoist to here
 	 * @param {boolean} recordEveryReference whether every binding collects its references, not only the ones webpack reads
@@ -124,8 +127,10 @@ class Scope {
 	constructor(type, block, upper, isVarScope, recordEveryReference) {
 		/** @type {ScopeType} */
 		this.type = type;
-		/** @type {Node} */
-		this.block = block;
+		/** @type {string} the type of the node that opened this scope */
+		this.blockType = block.type;
+		/** @type {number} where that node starts */
+		this.blockStart = /** @type {Node & Offset} */ (block).start;
 		/** @type {Scope | null} */
 		this.upper = upper;
 		/** @type {Scope[]} */
@@ -389,10 +394,26 @@ class ScopeAnalyzer {
 		this.pendingIdentifiers = [];
 		/** @type {Scope[]} the scope each pending identifier was seen in */
 		this.pendingScopes = [];
+		/** @type {Set<number>} where each shorthand property's identifier starts */
+		this.shorthandIdentifierStarts = new Set();
 		/** @type {boolean} */
 		this.recordEveryReference = recordEveryReference;
 	}
 
+	/**
+	 * Records where a shorthand property's identifier starts, so renaming it
+	 * later needs the offset rather than the tree it was read from.
+	 * @param {Property} property a property whose `shorthand` is set
+	 * @returns {void}
+	 */
+	_recordShorthandIdentifier(property) {
+		const value = property.value;
+		const identifier = value.type === "AssignmentPattern" ? value.left : value;
+		this.shorthandIdentifierStarts.add(
+			/** @type {Identifier & Offset} */ (identifier).start
+		);
+	}
+
 	/**
 	 * @param {ScopeType} type scope kind
 	 * @param {Node} block node opening the scope
@@ -512,6 +533,7 @@ class ScopeAnalyzer {
 				}
 				return;
 			case "Property":
+				if (node.shorthand) this._recordShorthandIdentifier(node);
 				if (node.computed) rightHandNodes.push(node.key);
 				this._patternWalk(node.value, mode, target, defaults, rightHandNodes);
 				return;
@@ -794,6 +816,11 @@ class ScopeAnalyzer {
 				return;
 
 			case "Property":
+				if (node.shorthand) this._recordShorthandIdentifier(node);
+				if (node.computed) this._visit(node.key);
+				this._visit(node.value);
+				return;
+
 			case "MethodDefinition":
 				if (node.computed) this._visit(node.key);
 				this._visit(node.value);
@@ -1068,6 +1095,7 @@ class ScopeAnalyzer {
  * @property {Scope} globalScope the outermost scope
  * @property {Scope} moduleScope the module body scope, where top-level declarations live
  * @property {Reference[]} unresolvedReferences every identifier that resolved to no binding — the module's free names
+ * @property {Set<number>} shorthandIdentifierStarts where each shorthand property's identifier starts, so a rename can write `name: newName` without the tree
  */
 
 /**
@@ -1084,11 +1112,3818 @@ const analyzeScope = (ast, recordEveryReference = false) => {
 	const moduleScope = analyzer._push("module", ast, true);
 	analyzer._visitAll(ast.body);
 	const unresolvedReferences = analyzer._resolve();
-	return { globalScope, moduleScope, unresolvedReferences };
+	return {
+		globalScope,
+		moduleScope,
+		unresolvedReferences,
+		shorthandIdentifierStarts: analyzer.shorthandIdentifierStarts
+	};
+};
+
+/**
+ * @typedef {import("./syntax-printer").PrintNode} PrintNode
+ * @typedef {import("./syntax-printer").PrintProgram} PrintProgram
+ * @typedef {import("./syntax-printer").PrintIdentifier} PrintIdentifier
+ * @typedef {import("./syntax-printer").PrintLiteral} PrintLiteral
+ * @typedef {import("./syntax-printer").PrintFunction} PrintFunction
+ * @typedef {import("./syntax-printer").PrintClass} PrintClass
+ * @typedef {import("./syntax-printer").PrintProperty} PrintProperty
+ * @typedef {import("./syntax-printer").PrintObject} PrintObject
+ * @typedef {import("./syntax-printer").PrintArray} PrintArray
+ * @typedef {import("./syntax-printer").PrintCallExpression} PrintCallExpression
+ * @typedef {import("./syntax-printer").PrintNewExpression} PrintNewExpression
+ * @typedef {import("./syntax-printer").PrintForStatement} PrintForStatement
+ * @typedef {import("./syntax-printer").PrintForInStatement} PrintForInStatement
+ * @typedef {import("./syntax-printer").PrintForOfStatement} PrintForOfStatement
+ * @typedef {import("./syntax-printer").PrintWhileStatement} PrintWhileStatement
+ * @typedef {import("./syntax-printer").PrintVariableDeclaration} PrintVariableDeclaration
+ * @typedef {import("./syntax-printer").PrintVariableDeclarator} PrintVariableDeclarator
+ * @typedef {import("./syntax-printer").PrintExport} PrintExport
+ * @typedef {import("./syntax-printer").Token} Token
+ * @typedef {NonNullable<PrintProgram["tokenTables"]>} TokenTables
+ * @typedef {import("./syntax-printer").Node} CompressorNode
+ * @typedef {import("./syntax-printer").Scope} CompressorScopeShape
+ * @typedef {import("./syntax-printer").Definition} CompressorDefinition
+ */
+
+// How a minifier definition's name was declared, one code per kind of
+// terser's declaring symbol; a global is a name nothing declares.
+const DECLARES_VAR = 1;
+const DECLARES_FUNARG = 2;
+const DECLARES_LET = 3;
+const DECLARES_CONST = 4;
+const DECLARES_USING = 5;
+const DECLARES_CATCH = 6;
+const DECLARES_IMPORT = 7;
+
+// What a name one long saves taking the name spelled beside it: a key's `:`
+// and the name, or an import's or export's ` as ` and the name.
+const SHORTHAND_SAVING = 2;
+const AS_SAVING = 5;
+// `spelledNames` collecting the names a key spells too, not only a module's.
+const SPELLED_KEYS = 2;
+// A name the mangler may hand out as it is spelled: one ASCII identifier, so it
+// prints bare and costs a byte a character.
+const SPELLABLE_NAME = /^[A-Za-z_$][\w$]*$/;
+// Names no binding may take in strict code, a module's, beyond the keywords.
+const NAMES_NO_BINDING_TAKES = new Set([
+	"arguments",
+	"await",
+	"enum",
+	"eval",
+	"implements",
+	"interface",
+	"let",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"yield"
+]);
+const DECLARES_DEFUN = 8;
+const DECLARES_LAMBDA = 9;
+const DECLARES_CLASS = 10;
+const DECLARES_DEF_CLASS = 11;
+const DECLARES_GLOBAL = 12;
+
+// The declarations a `var` or a parameter may not join, as `declarations` bits.
+const LEXICAL_DECLARATIONS =
+	(1 << DECLARES_LET) | (1 << DECLARES_CONST) | (1 << DECLARES_USING);
+
+// What the minifier's analysis records of a name read, replayed once all is
+// declared.
+const REFERENCE_CALLED = 1;
+const REFERENCE_EXPORTED = 1 << 1;
+const REFERENCE_FROM_MODULE = 1 << 2;
+const REFERENCE_CATCH = 1 << 3;
+
+// How an `export` naming a definition keeps its name.
+const EXPORT_KEEP_NAME = 1;
+const EXPORT_WANT_MANGLE = 2;
+
+// Past this many definitions a scope's `enclosed` is also held as a set, so
+// adding one stops scanning the list: a bundle's toplevel reaches thousands.
+const ENCLOSED_INDEX_THRESHOLD = 16;
+/** @type {WeakMap<MinifierVariable[], Set<MinifierVariable>>} */
+const enclosedIndexes = new WeakMap();
+
+/**
+ * Adds a definition to a scope's `enclosed` unless it is there. The list is
+ * the record, since a cloned scope copies it; the set only answers membership.
+ * @param {MinifierScope} scope a scope
+ * @param {MinifierVariable} definition a definition it reaches
+ * @returns {void}
+ */
+const encloseUnique = (scope, definition) => {
+	const { enclosed } = scope;
+	if (enclosed.length < ENCLOSED_INDEX_THRESHOLD) {
+		if (!enclosed.includes(definition)) enclosed.push(definition);
+		return;
+	}
+	let index = enclosedIndexes.get(enclosed);
+	if (index === undefined || index.size !== enclosed.length) {
+		index = new Set(enclosed);
+		enclosedIndexes.set(enclosed, index);
+	}
+	if (index.has(definition)) return;
+	index.add(definition);
+	enclosed.push(definition);
+};
+
+/**
+ * A scope as the minifier reads it: terser's, which opens one for every block
+ * and loop, besides what it names in.
+ */
+class MinifierScope extends Scope {
+	/**
+	 * @param {ScopeType} type what opened this scope
+	 * @param {PrintNode} node the node opening it
+	 * @param {MinifierScope | null} upper the enclosing scope
+	 * @param {boolean} isVarScope whether `var` and function declarations hoist to here
+	 */
+	constructor(type, node, upper, isVarScope) {
+		super(type, /** @type {Node} */ (node), upper, isVarScope, false);
+		/** @type {PrintNode} */
+		this.node = node;
+		/** @type {MinifierVariable[]} the definitions it or a scope inside it reads, in the order first read */
+		this.enclosed = [];
+		/** @type {number} how many names it has handed out, less one */
+		this.cname = -1;
+		/** @type {boolean} whether a direct `eval` can reach its names */
+		this.usesEval = false;
+		/** @type {boolean} whether a `with` can reach its names */
+		this.usesWith = false;
+		/** @type {MinifierVariable | null} a function expression's own name */
+		this.functionName = null;
+		/** @type {number} the first name its parameter list reads, as the analysis counts them, or -1 */
+		this.parameterStart = -1;
+		/** @type {number} the name after the last its parameter list reads, or -1 */
+		this.parameterEnd = -1;
+	}
+
+	/**
+	 * terser's `is_block_scope`.
+	 * @returns {boolean} whether a block or a loop opens it
+	 */
+	isBlockScope() {
+		return this.variableScope !== this;
+	}
+
+	/**
+	 * terser's `get_defun_scope`.
+	 * @returns {MinifierScope} the nearest scope around it, or it, that is not a block's
+	 */
+	getDefunScope() {
+		return /** @type {MinifierScope} */ (this.variableScope);
+	}
+
+	/**
+	 * terser's `pinned`.
+	 * @returns {boolean} whether `eval` or `with` can reach its names
+	 */
+	isPinned() {
+		return this.usesEval || this.usesWith;
+	}
+
+	/**
+	 * terser's `find_variable`.
+	 * @param {string} name a name
+	 * @returns {MinifierVariable | undefined} what it resolves to from here
+	 */
+	findVariable(name) {
+		return findMinifierVariable(this, name);
+	}
+
+	/**
+	 * terser's `conflicting_def_shallow`.
+	 * @param {string} name a name
+	 * @returns {boolean} whether it is declared here or names a definition read here
+	 */
+	conflictingDefinitionShallow(name) {
+		const { enclosed } = this;
+		for (let i = 0; i < enclosed.length; i++) {
+			if (enclosed[i].name === name) return true;
+		}
+		return this.getBinding(name) !== undefined;
+	}
+
+	/**
+	 * terser's `conflicting_def`.
+	 * @param {string} name a name
+	 * @returns {boolean} whether it is taken here or further out
+	 */
+	conflictingDefinition(name) {
+		for (
+			let scope = /** @type {MinifierScope | null} */ (this);
+			scope !== null;
+			scope = /** @type {MinifierScope | null} */ (scope.upper)
+		) {
+			if (scope.conflictingDefinitionShallow(name)) return true;
+		}
+		return false;
+	}
+
+	/**
+	 * terser's `mark_enclosed`: records that each scope from this one out to a
+	 * definition's reads it.
+	 * @param {MinifierVariable} variable the definition
+	 * @returns {void}
+	 */
+	markEnclosed(variable) {
+		encloseVariable(this, variable);
+	}
+}
+
+/**
+ * One name declared in one scope, or a global: terser's `SymbolDef`, less
+ * what only the compressor reads.
+ */
+class MinifierVariable extends Variable {
+	/**
+	 * @param {string} name the declared name
+	 * @param {MinifierScope} scope the declaring scope, the toplevel for a global
+	 * @param {number} kind how it was first declared, as a `DECLARES_*` code
+	 */
+	constructor(name, scope, kind) {
+		super(name, scope);
+		/** @type {number} how it was first declared, as a `DECLARES_*` code */
+		this.kind = kind;
+		/** @type {number} every way it was declared, one bit per `DECLARES_*` code */
+		this.declarations = 1 << kind;
+		/** @type {boolean} whether the toplevel declares it */
+		this.global = false;
+		/** @type {boolean} whether nothing declares it */
+		this.undeclared = false;
+		/** @type {number} how an `export` naming it keeps its name, as `EXPORT_*` */
+		this.export = 0;
+		/** @type {string | null} the name mangling gives it */
+		// eslint-disable-next-line camelcase -- terser's name, which the printer reads
+		this.mangled_name = null;
+		/** @type {number} how many names read or write it, which the mangler gives the short names by */
+		this.referenceCount = 0;
+	}
+}
+
+/**
+ * Whether a definition is a variable rather than a label or a compressor's own definition.
+ * @param {unknown} value a definition
+ * @returns {value is MinifierVariable} true when the value is a variable
+ */
+const isMinifierVariable = (value) => value instanceof MinifierVariable;
+
+/** A label: a statement's, its `break`s and `continue`s naming it too. */
+class MinifierLabel {
+	/**
+	 * @param {string} name the name
+	 * @param {MinifierLabel | null} parent the label of the nearest labeled statement around, across functions
+	 */
+	constructor(name, parent) {
+		/** @type {string} */
+		this.name = name;
+		/** @type {string | null} the name mangling gives it */
+		// eslint-disable-next-line camelcase -- terser's name, which the printer reads
+		this.mangled_name = null;
+		/** @type {MinifierLabel | null} */
+		this.parent = parent;
+		/** @type {number} where the mangler's label names stood when it named this one */
+		this.counter = -1;
+	}
+}
+
+/**
+ * A scope as the compressor reads it: the minifier's, and what terser's
+ * compressor records of it besides. The node opening it holds it as its
+ * `block_scope`, a function's or the program's as a block's does.
+ */
+class CompressorScope extends MinifierScope {
+	/**
+	 * @param {ScopeType} type what opened this scope
+	 * @param {CompressorNode} node the node opening it
+	 * @param {CompressorScopeShape | null} upper the enclosing scope
+	 * @param {boolean} isVarScope whether `var` and function declarations hoist to here
+	 */
+	constructor(type, node, upper, isVarScope) {
+		// Made with no parent, so the parent lists no child: the compressor never
+		// reads `childScopes`, and its tree moves, copies and drops scopes.
+		super(
+			type,
+			/** @type {PrintNode} */ (/** @type {unknown} */ (node)),
+			null,
+			true
+		);
+		this.upper = /** @type {Scope | null} */ (/** @type {unknown} */ (upper));
+		if (!isVarScope) {
+			this.variableScope = /** @type {Scope} */ (this.upper).variableScope;
+		}
+		/** @type {boolean} whether a function reads its own `arguments` */
+		this.usesArguments = false;
+		/** @type {import("./syntax-printer").UnusedScanLog | null} what `drop_unused` found scanning the function, for the scopes around it */
+		this.unusedScan = null;
+		/** @type {number} where the symbols under this scope's node start in the reduce phase's symbol order */
+		this.hoistStart = 0;
+		/** @type {number} where they end, exclusive */
+		this.hoistEnd = 0;
+	}
+
+	/**
+	 * The scope of a node made of this scope's node: as terser's node was a
+	 * scope, it is a scope of its own, holding and reading the same definitions.
+	 * @param {CompressorNode} node the node made of this scope's
+	 * @returns {CompressorScopeShape} the scope
+	 */
+	share(node) {
+		const shared = new CompressorScope(
+			this.type,
+			node,
+			/** @type {CompressorScopeShape | null} */ (
+				/** @type {unknown} */ (this.upper)
+			),
+			this.variableScope === this
+		);
+		shared.variables = this.variables;
+		shared._index = this._index;
+		shared.enclosed = this.enclosed;
+		shared.usesEval = this.usesEval;
+		shared.usesWith = this.usesWith;
+		shared.usesArguments = this.usesArguments;
+		return /** @type {CompressorScopeShape} */ (
+			/** @type {unknown} */ (shared)
+		);
+	}
+
+	/**
+	 * Takes copies of what this scope shares with the scope it was made of, as
+	 * terser's `clone` of a scope does.
+	 * @returns {void}
+	 */
+	detach() {
+		if (this.variables !== NO_VARIABLE_LIST) {
+			this.variables = [...this.variables];
+		}
+		if (this._index !== undefined) this._index = new Map(this._index);
+		this.enclosed = [...this.enclosed];
+	}
+
+	/**
+	 * A copy of this scope for a copy of its node.
+	 * @param {CompressorNode} node the copy of its node
+	 * @returns {CompressorScopeShape} the copy
+	 */
+	copyFor(node) {
+		const copy = this.share(node);
+		copy.detach();
+		return copy;
+	}
+
+	/**
+	 * Adds a definition this scope declares under its name.
+	 * @param {CompressorDefinition} variable the definition
+	 * @returns {void}
+	 */
+	bind(variable) {
+		addBinding(
+			this,
+			/** @type {Variable} */ (/** @type {unknown} */ (variable))
+		);
+	}
+
+	/**
+	 * terser's `def_variable`: declares a symbol's name here.
+	 * @param {CompressorNode} symbol the declaring symbol
+	 * @param {CompressorNode | null | undefined} init what it is initialized to
+	 * @param {(node: CompressorNode) => boolean} isFunction whether a node is a function expression
+	 * @returns {CompressorDefinition} its definition, made or joined
+	 */
+	defineVariable(symbol, init, isFunction) {
+		const name = /** @type {string} */ (symbol.name);
+		let variable = /** @type {CompressorDefinition | undefined} */ (
+			/** @type {unknown} */ (this.getBinding(name))
+		);
+		if (variable !== undefined) {
+			variable.identifiers.push(symbol);
+			if (
+				variable.init &&
+				(variable.scope !== /** @type {unknown} */ (symbol.scope) ||
+					isFunction(variable.init))
+			) {
+				variable.init = init;
+			}
+		} else {
+			variable = createCompressorDefinition(
+				name,
+				/** @type {CompressorScopeShape} */ (/** @type {unknown} */ (this)),
+				0,
+				symbol,
+				init
+			);
+			this.bind(variable);
+			variable.global = this.upper === null;
+		}
+		return (symbol.definition = variable);
+	}
+
+	/**
+	 * terser's `add_child_scope`: moves a function's or class's scope into this
+	 * one, which with each scope around it reads what the moved one reads from
+	 * them. Nothing lists a compressor scope's children, so nothing else moves.
+	 * @param {CompressorScopeShape} child the scope moved in
+	 * @param {(() => boolean) | null} readsArguments for an arrow, whether it reads the `arguments` of the function it moves into
+	 * @returns {void}
+	 */
+	adopt(child, readsArguments) {
+		const self = /** @type {CompressorScopeShape} */ (
+			/** @type {unknown} */ (this)
+		);
+		if (child.upper === self) return;
+		child.upper = self;
+		if (
+			readsArguments !== null &&
+			this.type === "function" &&
+			!this.usesArguments
+		) {
+			this.usesArguments = readsArguments();
+		}
+		this.usesWith = this.usesWith || child.usesWith;
+		this.usesEval = this.usesEval || child.usesEval;
+		/** @type {CompressorScopeShape[]} */
+		const ancestry = [];
+		for (
+			let current = /** @type {CompressorScopeShape | null} */ (self);
+			current !== null;
+			current = current.upper
+		) {
+			ancestry.push(current);
+		}
+		ancestry.reverse();
+		const enclosedByChild = new Set(child.enclosed);
+		/** @type {CompressorDefinition[]} */
+		const toEnclose = [];
+		for (const ancestor of ancestry) {
+			const scope = /** @type {MinifierScope} */ (
+				/** @type {unknown} */ (ancestor)
+			);
+			for (const definition of toEnclose) {
+				encloseUnique(
+					scope,
+					/** @type {MinifierVariable} */ (/** @type {unknown} */ (definition))
+				);
+			}
+			const { variables } = ancestor;
+			// Where the moved scope encloses fewer names than this one declares,
+			// they are looked up here, and the variables read in order only to
+			// order two or more of them.
+			let left = variables.length;
+			/** @type {CompressorDefinition | undefined} */
+			let declared;
+			if (left > enclosedByChild.size) {
+				left = 0;
+				for (const definition of enclosedByChild) {
+					if (ancestor.getBinding(definition.name) !== definition) continue;
+					declared = definition;
+					left++;
+				}
+				if (left === 0) continue;
+				if (left === 1) {
+					const only = /** @type {CompressorDefinition} */ (declared);
+					if (!toEnclose.includes(only)) toEnclose.push(only);
+					encloseUnique(
+						scope,
+						/** @type {MinifierVariable} */ (/** @type {unknown} */ (only))
+					);
+					continue;
+				}
+			}
+			for (let i = 0; i < variables.length; i++) {
+				const definition = variables[i];
+				if (enclosedByChild.has(definition)) {
+					if (!toEnclose.includes(definition)) toEnclose.push(definition);
+					encloseUnique(
+						scope,
+						/** @type {MinifierVariable} */ (
+							/** @type {unknown} */ (definition)
+						)
+					);
+					if (--left === 0) break;
+				}
+			}
+		}
+	}
+
+	/**
+	 * terser's `add_reference`: a symbol in this scope reads its definition.
+	 * @param {CompressorNode} symbol the symbol
+	 * @returns {void}
+	 */
+	addReference(symbol) {
+		const variable = symbol.definition;
+		variable.references.push(symbol);
+		encloseVariable(
+			this,
+			/** @type {MinifierVariable} */ (/** @type {unknown} */ (variable))
+		);
+	}
+}
+
+let nextCompressorVariableId = 1;
+
+/**
+ * One name declared in one scope, or a global: terser's `SymbolDef`, its
+ * `orig` the base's `identifiers`, with what the compressor records of it.
+ */
+class CompressorVariable extends MinifierVariable {
+	/**
+	 * @param {string} name the declared name
+	 * @param {CompressorScopeShape | null} scope the declaring scope, the toplevel for a global
+	 * @param {number} kind how it was first declared, as a `DECLARES_*` code, 0 where the compressor declares it
+	 * @param {CompressorNode | { name: string }} orig its first declaring symbol
+	 * @param {CompressorNode | null | undefined} init what it is initialized to
+	 */
+	constructor(name, scope, kind, orig, init) {
+		super(
+			name,
+			/** @type {MinifierScope} */ (/** @type {unknown} */ (scope)),
+			kind
+		);
+		this.identifiers = [
+			/** @type {Identifier} */ (/** @type {unknown} */ (orig))
+		];
+		/** @type {CompressorNode | null | undefined} what it is initialized to */
+		this.init = init;
+		/** @type {number} a number no other definition has, in the order made */
+		this.id = nextCompressorVariableId++;
+		/* eslint-disable camelcase -- terser's names, which the compressor reads */
+		/** @type {number} how many of its declarations were dropped */
+		this.eliminated = 0;
+		/** @type {number} how many times it is assigned */
+		this.assignments = 0;
+		/** @type {number} how many times a destructuring pattern or a loop head names it, each a write `assignments` misses */
+		this.patternWrites = 0;
+		/** @type {number} how many of its reads were replaced by its value */
+		this.replaced = 0;
+		/** @type {boolean} whether it is assigned in a chain */
+		this.chained = false;
+		/** @type {boolean} whether its value is read where it may be changed */
+		this.direct_access = false;
+		/** @type {number} how many properties are read off it before its value escapes, 0 where it does not */
+		this.escaped = 0;
+		/** @type {boolean} whether its value itself escapes, not only a property read off it */
+		this.leaked = false;
+		/** @type {number} how many of its reads are its own function's calls of itself */
+		this.recursive_refs = 0;
+		/** @type {boolean | string | undefined} whether it is read once, "m" where that read may change it */
+		this.single_use = false;
+		/** @type {CompressorNode | (() => CompressorNode) | false | null | undefined} its value, as `reduce_vars` worked it out, false where unknown */
+		this.fixed = false;
+		/* eslint-enable camelcase */
+		/** @type {Reference[]} the symbols reading it, which `SymbolDefinition` types as nodes */
+		this.references = [];
+		/** @type {number} the last `drop_unused` run to find it in use, 0 for none */
+		this.inUseRun = 0;
+		/** @type {CompressorNode | undefined} the name a copy of it was set from, kept where a write through the copy dropped `fixed` */
+		this.copyOf = undefined;
+	}
+}
+
+/**
+ * A definition the compressor reads, typed as it reads the shared model.
+ * @param {string} name the declared name
+ * @param {CompressorScopeShape | null} scope the declaring scope, the toplevel for a global
+ * @param {number} kind how it was first declared, as a `DECLARES_*` code, 0 where the compressor declares it
+ * @param {CompressorNode | { name: string }} orig its first declaring symbol
+ * @param {CompressorNode | null | undefined} init what it is initialized to
+ * @returns {CompressorDefinition} the definition
+ */
+const createCompressorDefinition = (name, scope, kind, orig, init) =>
+	/** @type {CompressorDefinition} */ (
+		/** @type {unknown} */ (
+			new CompressorVariable(name, scope, kind, orig, init)
+		)
+	);
+
+/**
+ * A scope the compressor reads, typed as it reads the shared model.
+ * @param {ScopeType} type what opened this scope
+ * @param {CompressorNode} node the node opening it
+ * @param {CompressorScopeShape | null} upper the enclosing scope
+ * @param {boolean} isVarScope whether `var` and function declarations hoist to here
+ * @returns {CompressorScopeShape} the scope
+ */
+const createCompressorScope = (type, node, upper, isVarScope) =>
+	/** @type {CompressorScopeShape} */ (
+		/** @type {unknown} */ (new CompressorScope(type, node, upper, isVarScope))
+	);
+
+/**
+ * The options the minifier's analysis reads, its mangle options among them.
+ * @typedef {object} MinifierScopeOptions
+ * @property {boolean=} module whether the program is a module, so strict
+ * @property {boolean=} ie8 whether catch parameters belong to their function
+ * @property {boolean=} safari10 whether a loop's scope reads its parent's names, and catch parameters belong to their function
+ * @property {boolean | RegExp=} keep_fnames which function names survive, collecting the declarators naming one
+ * @property {boolean | RegExp=} keep_classnames which class names survive, collecting the declarators naming one under `classDeclarators`
+ * @property {boolean=} classDeclarators whether, under `keep_classnames`, the names declarators give anonymous classes are kept as `keep_fnames` keeps a function's
+ * @property {boolean=} parameterScopes whether names are scoped as the spec scopes them where terser does not: a parameter list's or a catch parameter's reads skip what the body declares, and a block's async or generator function stays in the block
+ * @property {number=} spelledNames which names to collect that the mangler may give the name beside them to write less: 1 for an import's or export's, 2 for a key's too
+ */
+
+/**
+ * @typedef {object} MinifierScopeAnalysis
+ * @property {MinifierScope} toplevel the program's scope, its `childScopes` in the order the mangler walks them
+ * @property {MinifierLabel[]} labels every label, in the same order
+ * @property {Map<string, MinifierVariable>} globals the names nothing declares, in the order first read
+ * @property {Set<MinifierScope>} blockDefunScopes the function scopes holding a function declared in a block
+ * @property {PrintIdentifier[] | null} functionDeclarators under `keep_fnames`, the names declarators give anonymous functions, in the order the mangler asks `keep_fnames` of them
+ * @property {PrintIdentifier[] | null} classDeclarators under `classDeclarators` and `keep_classnames`, the names declarators give anonymous classes
+ * @property {PrintIdentifier[]} catchParameters unless `ie8` or `safari10` move them, the catch parameters, each named where the mangler's walk meets its scope
+ * @property {boolean} namesPrivate whether the program names a private member, which renaming walks it for
+ * @property {SpelledNames | null} spelledNames under `spelledNames`, the names a key or an import or export spells for a name beside it
+ */
+
+/**
+ * Where a name stands beside one spelled for it: a property's key, which the
+ * name as its value lets print alone, or an import's or export's other name.
+ * @typedef {object} SpelledNames
+ * @property {PrintIdentifier[]} identifiers each name, its `definition` read once the analysis resolves
+ * @property {string[]} spellings the name spelled beside each
+ * @property {number[]} savings the characters each saves, its own name one long, where it takes the name spelled
+ */
+
+/**
+ * @param {PrintNode} node a node
+ * @returns {boolean} whether terser holds it as a scope its statements sit in directly
+ */
+const isStatementScope = (node) =>
+	node.type === "Program" ||
+	node.type === "FunctionDeclaration" ||
+	node.type === "FunctionExpression" ||
+	node.type === "ArrowFunctionExpression" ||
+	node.type === "StaticBlock";
+
+/**
+ * @param {PrintNode | null} node a binding pattern, `null` for an array's hole
+ * @param {string} name a name
+ * @returns {boolean} whether the pattern binds the name
+ */
+const bindsName = (node, name) => {
+	if (node === null) return false;
+	switch (node.type) {
+		case "ObjectPattern":
+			return node.properties.some((property) =>
+				bindsName(
+					property.type === "Property" ? property.value : property,
+					name
+				)
+			);
+		case "ArrayPattern":
+			return node.elements.some((element) => bindsName(element, name));
+		case "AssignmentPattern":
+			return bindsName(node.left, name);
+		case "RestElement":
+			return bindsName(node.argument, name);
+		default:
+			return /** @type {PrintIdentifier} */ (node).name === name;
+	}
+};
+
+/**
+ * @param {PrintNode | null} node a statement, or a loop's head
+ * @param {string} name a name
+ * @returns {boolean} whether it declares the name with `let`, `const`, `using` or a class
+ */
+const declaresLexically = (node, name) =>
+	node !== null &&
+	(node.type === "VariableDeclaration"
+		? node.kind !== "var" &&
+			node.declarations.some((declarator) =>
+				bindsName(/** @type {PrintVariableDeclarator} */ (declarator).id, name)
+			)
+		: node.type === "ClassDeclaration" &&
+			/** @type {PrintIdentifier} */ (node.id).name === name);
+
+/**
+ * @param {PrintNode} node a node
+ * @returns {node is PrintExport} whether it is an `export`
+ */
+const isExport = (node) =>
+	node.type === "ExportNamedDeclaration" ||
+	node.type === "ExportDefaultDeclaration" ||
+	node.type === "ExportAllDeclaration";
+
+/**
+ * @param {MinifierScope} scope the scope declaring it
+ * @param {MinifierVariable} variable a definition
+ * @param {number} read the read's place in the analysis's count
+ * @returns {boolean} whether the read sits in the scope's parameter list and the definition in its body, which the list cannot see
+ */
+const isHiddenFromParameters = (scope, variable, read) =>
+	read < scope.parameterEnd &&
+	read >= scope.parameterStart &&
+	variable.kind !== DECLARES_FUNARG &&
+	variable.kind !== DECLARES_LAMBDA &&
+	variable.kind !== DECLARES_CATCH;
+
+/**
+ * @param {MinifierScope} from the scope a name is read in
+ * @param {string} name the name
+ * @param {number=} read the read's place in the analysis's count, under `parameterScopes`
+ * @returns {MinifierVariable | undefined} what it resolves to from there
+ */
+const findMinifierVariable = (from, name, read = -1) => {
+	for (let scope = /** @type {Scope | null} */ (from); scope !== null;) {
+		// `getBinding`, inlined: the interpreter pays a call per scope climbed
+		const index = scope._index;
+		/** @type {MinifierVariable | undefined} */
+		let variable;
+		if (index !== undefined) {
+			variable = /** @type {MinifierVariable | undefined} */ (index.get(name));
+		} else {
+			const variables = scope.variables;
+			for (let i = 0; i < variables.length; i++) {
+				if (variables[i].name === name) {
+					variable = /** @type {MinifierVariable} */ (variables[i]);
+					break;
+				}
+			}
+		}
+		if (
+			variable !== undefined &&
+			!isHiddenFromParameters(
+				/** @type {MinifierScope} */ (scope),
+				variable,
+				read
+			)
+		) {
+			return variable;
+		}
+		scope = scope.upper;
+	}
+	return undefined;
+};
+
+/**
+ * terser's `mark_enclosed`: each scope from one out to a definition's reads it.
+ * @param {MinifierScope} from the scope reading it
+ * @param {MinifierVariable} variable the definition
+ * @returns {void}
+ */
+const encloseVariable = (from, variable) => {
+	for (let scope = /** @type {Scope | null} */ (from); scope !== null;) {
+		encloseUnique(/** @type {MinifierScope} */ (scope), variable);
+		if (scope === variable.scope) break;
+		scope = scope.upper;
+	}
+};
+
+/**
+ * Analyses the minifier's tree as terser's `figure_out_scope` does for its
+ * mangler: the same scopes, definitions, enclosed lists and errors, in the
+ * same orders, which the names it hands out depend on. Every name's
+ * `definition` is set: its definition, its label, or null.
+ */
+class MinifierScopeAnalyzer extends ScopeAnalyzer {
+	/**
+	 * @param {PrintProgram} program the tree, its names as written
+	 * @param {MinifierScopeOptions} options the mangle options
+	 * @param {(node: PrintNode, message: string, tables?: TokenTables) => never} raise throws the parse error a misplaced declaration is
+	 * @param {((node: PrintNode) => void) | undefined} release drops what only the compressor read off each node read, where nobody keeps the tree
+	 */
+	constructor(program, options, raise, release) {
+		super(false);
+		/** @type {(node: PrintNode, message: string, tables?: TokenTables) => never} */
+		this.raise = raise;
+		/** @type {((node: PrintNode) => void) | undefined} */
+		this.release = release;
+		// What the tree's token numbers are read through, for a message's place.
+		/** @type {TokenTables | undefined} */
+		this.tokenTables = program.tokenTables || undefined;
+		/** @type {boolean} */
+		this.legacyCatch = Boolean(options.ie8 || options.safari10);
+		/** @type {boolean} */
+		this.safari10 = Boolean(options.safari10);
+		/** @type {boolean} */
+		this.parameterScopes = Boolean(options.parameterScopes);
+		// Only this analysis's reads are counted against a range, so each is
+		// cleared once they resolve, before an analysis of a copy counts anew.
+		/** @type {MinifierScope[]} the scopes holding a range of parameter reads */
+		this.parameterRanges = [];
+		/** @type {MinifierScope} */
+		this.toplevel = new MinifierScope("global", program, null, true);
+		this.scope = this.toplevel;
+		/** @type {MinifierLabel[]} */
+		this.labels = [];
+		/** @type {Map<string, MinifierVariable>} */
+		this.globals = new Map();
+		/** @type {Set<MinifierScope>} */
+		this.blockDefunScopes = new Set();
+		/** @type {PrintIdentifier[] | null} */
+		this.functionDeclarators = options.keep_fnames ? [] : null;
+		/** @type {PrintIdentifier[] | null} */
+		this.classDeclarators =
+			options.classDeclarators && options.keep_classnames ? [] : null;
+		/** @type {MinifierScope[]} */
+		this.forScopes = [];
+		// The names read, and catch parameters, in the order terser's walk meets them.
+		/** @type {(PrintIdentifier | PrintLiteral)[]} */
+		this.referenceNodes = [];
+		/** @type {MinifierScope[]} */
+		this.referenceScopes = [];
+		/** @type {number[]} */
+		this.referenceFlags = [];
+		// Under `ie8` or `safari10`, the catch parameters in `walk`'s order.
+		/** @type {PrintIdentifier[]} */
+		this.catchNames = [];
+		/** @type {MinifierScope[]} */
+		this.catchScopes = [];
+		// Otherwise the catch parameters, which the mangler names with their scope.
+		/** @type {PrintIdentifier[]} */
+		this.catchParameters = [];
+		/** @type {boolean} whether the program names a private member */
+		this.namesPrivate = false;
+		/** @type {PrintNode[]} the nodes terser's walk has pushed, the node visited last */
+		this.stack = [];
+		/** @type {boolean} */
+		this.strict = Boolean(options.module);
+		/** @type {Map<string, MinifierLabel>} the labels of the statements around, up to the nearest function */
+		this.labelsInScope = new Map();
+		/** @type {MinifierLabel | null} */
+		this.currentLabel = null;
+		/** @type {PrintNode | null} the pattern the walk is inside, which `_markExport` counts from */
+		this.inDestructuring = null;
+		/** @type {SpelledNames | null} */
+		this.spelledNames = options.spelledNames
+			? { identifiers: [], spellings: [], savings: [] }
+			: null;
+		/** @type {boolean} whether a key spells a name, which prints alone where it is its value's */
+		this.spelledKeys = options.spelledNames === SPELLED_KEYS;
+	}
+
+	/**
+	 * Collects a name and one spelled beside it, under `spelledNames`.
+	 * @param {PrintNode | null} identifier the name, if it is one
+	 * @param {PrintNode | null} spelled what spells the other, if a name
+	 * @param {number} saving the characters it saves taking that name
+	 * @returns {void}
+	 */
+	_spell(identifier, spelled, saving) {
+		const names = this.spelledNames;
+		if (
+			names === null ||
+			identifier === null ||
+			spelled === null ||
+			identifier.type !== "Identifier"
+		) {
+			return;
+		}
+		const spelling =
+			spelled.type === "Identifier"
+				? spelled.name
+				: spelled.type !== "Literal"
+					? undefined
+					: typeof spelled.value === "string"
+						? spelled.value
+						: // A module's quoted name holds its text as its name.
+							/** @type {{ name?: string }} */ (spelled).name;
+		if (
+			spelling === undefined ||
+			!SPELLABLE_NAME.test(spelling) ||
+			NAMES_NO_BINDING_TAKES.has(spelling) ||
+			// A shorthand `__proto__` is an own property; `__proto__:` sets the prototype.
+			spelling === "__proto__"
+		) {
+			return;
+		}
+		names.identifiers.push(/** @type {PrintIdentifier} */ (identifier));
+		names.spellings.push(spelling);
+		names.savings.push(saving);
+	}
+
+	/**
+	 * Collects a property's value named as its key could be, under `spelledNames`.
+	 * @param {PrintProperty} property a property of an object or a pattern
+	 * @returns {void}
+	 */
+	_spellProperty(property) {
+		if (!this.spelledKeys || property.computed) return;
+		const { value } = property;
+		this._spell(
+			value.type === "AssignmentPattern" ? value.left : value,
+			property.key,
+			SHORTHAND_SAVING
+		);
+	}
+
+	/**
+	 * @param {Token | number | null | undefined} token a node's token, or its number
+	 * @returns {Token | null | undefined} the token itself
+	 */
+	tokenOf(token) {
+		return this.tokenTables === undefined
+			? /** @type {Token | null | undefined} */ (token)
+			: this.tokenTables.of(token);
+	}
+
+	/**
+	 * @param {ScopeType} type what opens it
+	 * @param {PrintNode} node the node opening it
+	 * @param {boolean} isVarScope whether `var` hoists to here
+	 * @returns {MinifierScope} the scope, now current
+	 */
+	_open(type, node, isVarScope) {
+		const scope = new MinifierScope(
+			type,
+			node,
+			/** @type {MinifierScope} */ (this.scope),
+			isVarScope
+		);
+		this.scope = scope;
+		return scope;
+	}
+
+	/**
+	 * Opens a block's scope, which inherits whether a `with` reaches it.
+	 * @param {ScopeType} type what opens it
+	 * @param {PrintNode} node a block's node
+	 * @returns {MinifierScope} the scope it leaves, now the new scope's parent
+	 */
+	_enterBlock(type, node) {
+		const outer = /** @type {MinifierScope} */ (this.scope);
+		this._open(type, node, false).usesWith = outer.usesWith;
+		return outer;
+	}
+
+	/**
+	 * terser's `def_variable`.
+	 * @param {MinifierScope} target the scope declaring it
+	 * @param {PrintIdentifier | null} identifier the name declaring it, if written
+	 * @param {string} name the name
+	 * @param {number} kind how it is declared
+	 * @returns {MinifierVariable} its definition, made or joined
+	 */
+	_defineVariable(target, identifier, name, kind) {
+		return this._addDeclaration(
+			target,
+			/** @type {MinifierVariable | undefined} */ (target.getBinding(name)),
+			identifier,
+			name,
+			kind
+		);
+	}
+
+	/**
+	 * terser's `def_variable`, the scope's binding of the name already looked up.
+	 * @param {MinifierScope} target the scope declaring it
+	 * @param {MinifierVariable | undefined} variable what the scope binds the name to, if anything
+	 * @param {PrintIdentifier | null} identifier the name declaring it, if written
+	 * @param {string} name the name
+	 * @param {number} kind how it is declared
+	 * @returns {MinifierVariable} its definition, made or joined
+	 */
+	_addDeclaration(target, variable, identifier, name, kind) {
+		if (variable !== undefined) {
+			variable.declarations |= 1 << kind;
+		} else {
+			variable = new MinifierVariable(name, target, kind);
+			variable.global = target.upper === null;
+			if (this.legacyCatch && kind === DECLARES_CATCH) {
+				variable.references = [];
+			}
+			addBinding(target, variable);
+		}
+		if (identifier !== null) {
+			if (this.release !== undefined) this.release(identifier);
+			identifier.definition = variable;
+		}
+		return variable;
+	}
+
+	/**
+	 * terser's `reference`.
+	 * @param {PrintIdentifier} identifier the name read
+	 * @param {MinifierScope} from the scope reading it
+	 * @param {MinifierVariable} variable what it reads
+	 * @returns {void}
+	 */
+	_referenceVariable(identifier, from, variable) {
+		variable.referenceCount++;
+		if (variable.references !== NO_REFERENCES) {
+			variable.references.push(
+				new Reference(/** @type {Identifier} */ (identifier), from)
+			);
+		}
+		encloseVariable(from, variable);
+	}
+
+	/**
+	 * terser's `mark_export`, which counts its levels on terser's stack.
+	 * @param {MinifierVariable} variable a definition just made
+	 * @param {number} level where its declaration's statement is
+	 * @returns {void}
+	 */
+	_markExport(variable, level) {
+		const stack = this.stack;
+		if (this.inDestructuring !== null) {
+			let i = 0;
+			do {
+				level++;
+			} while (stack[stack.length - 1 - i++] !== this.inDestructuring);
+		}
+		const node = stack[stack.length - 1 - level];
+		if (node === undefined || !isExport(node)) {
+			variable.export = 0;
+			return;
+		}
+		// An ESTree tree read in makes a declaration a value terser keeps named.
+		const declaration = /** @type {PrintNode} */ (
+			node.exported_value || node.exported_definition
+		);
+		variable.export =
+			node.type === "ExportDefaultDeclaration" &&
+			Boolean(node.exported_definition) &&
+			(declaration.type === "FunctionDeclaration" ||
+				declaration.type === "ClassDeclaration")
+				? EXPORT_WANT_MANGLE
+				: EXPORT_KEEP_NAME;
+	}
+
+	/**
+	 * @param {PrintNode} node an import or export
+	 * @param {string} type terser's name for it
+	 * @returns {void}
+	 */
+	_checkModuleStatement(node, type) {
+		if (this.scope !== this.toplevel) {
+			this.raise(
+				node,
+				`"${type}" statement may only appear at the top level`,
+				this.tokenTables
+			);
+		}
+	}
+
+	/**
+	 * @param {PrintIdentifier | PrintLiteral} node a name read, or a re-exported string
+	 * @param {number} flags what else is known of it, as `REFERENCE_*` bits
+	 * @returns {void}
+	 */
+	_addReference(node, flags) {
+		if (this.release !== undefined) this.release(node);
+		this.referenceNodes.push(node);
+		this.referenceScopes.push(/** @type {MinifierScope} */ (this.scope));
+		this.referenceFlags.push(flags);
+	}
+
+	/**
+	 * A name a declaration or a pattern binds, or reads where `kind` is 0.
+	 * @param {PrintNode} node the name or pattern
+	 * @param {number} kind how it declares, as a `DECLARES_*` code, or 0
+	 * @returns {void}
+	 */
+	_visitBinding(node, kind) {
+		const stack = this.stack;
+		switch (node.type) {
+			case "Identifier":
+				if (kind === 0) this._visitPrint(node);
+				else this._declare(node, kind);
+				return;
+			case "ObjectPattern":
+				this._visitPattern(node, node.properties, kind);
+				return;
+			case "ArrayPattern":
+				this._visitPattern(node, node.elements, kind);
+				return;
+			case "AssignmentPattern":
+				stack.push(node);
+				this._visitBinding(node.left, kind);
+				this._visitPrint(node.right);
+				stack.pop();
+				return;
+			case "RestElement":
+				stack.push(node);
+				this._visitBinding(node.argument, kind);
+				stack.pop();
+				return;
+			default:
+				this._visitPrint(node);
+		}
+	}
+
+	/**
+	 * @param {PrintObject | PrintArray} pattern an object or array pattern
+	 * @param {(PrintNode | null)[]} elements its properties or elements, holes null
+	 * @param {number} kind how it declares, as a `DECLARES_*` code, or 0
+	 * @returns {void}
+	 */
+	_visitPattern(pattern, elements, kind) {
+		const stack = this.stack;
+		const outer = this.inDestructuring;
+		this.inDestructuring = pattern;
+		stack.push(pattern);
+		for (let i = 0; i < elements.length; i++) {
+			const element = elements[i];
+			if (!element) continue;
+			if (element.type !== "Property") {
+				this._visitBinding(element, kind);
+				continue;
+			}
+			stack.push(element);
+			if (element.computed) this._visitPrint(element.key);
+			this._visitBinding(element.value, kind);
+			this._spellProperty(element);
+			stack.pop();
+		}
+		stack.pop();
+		this.inDestructuring = outer;
+	}
+
+	/**
+	 * A `var`, parameter, `let`, `const`, `using`, catch parameter or import.
+	 * @param {PrintIdentifier} identifier the name declared
+	 * @param {number} kind how, as a `DECLARES_*` code
+	 * @returns {void}
+	 */
+	_declare(identifier, kind) {
+		const { name } = identifier;
+		const scope = /** @type {MinifierScope} */ (this.scope);
+		if (kind === DECLARES_IMPORT) {
+			this._defineVariable(scope, identifier, name, kind);
+			return;
+		}
+		const blockDeclaration =
+			kind === DECLARES_LET ||
+			kind === DECLARES_CONST ||
+			kind === DECLARES_USING ||
+			kind === DECLARES_CATCH;
+		const defun = /** @type {MinifierScope} */ (scope.variableScope);
+		const target = blockDeclaration ? scope : defun;
+		const before = /** @type {MinifierVariable | undefined} */ (
+			target.getBinding(name)
+		);
+		const earlier = before === undefined ? 0 : before.declarations;
+		const variable = this._addDeclaration(
+			target,
+			before,
+			identifier,
+			name,
+			kind
+		);
+		// A body's lexical `arguments` shadows the function's own, which is declared
+		// as a parameter here; a parameter so named beside it the parser refuses.
+		const shadowsOwnArguments =
+			this.parameterScopes &&
+			name === "arguments" &&
+			earlier === 1 << DECLARES_FUNARG;
+		if (
+			!shadowsOwnArguments &&
+			(blockDeclaration
+				? (earlier & ~(1 << DECLARES_LAMBDA)) !== 0
+				: (earlier & LEXICAL_DECLARATIONS) !== 0)
+		) {
+			this.raise(identifier, `"${name}" is redeclared`, this.tokenTables);
+		}
+		if (kind !== DECLARES_FUNARG) this._markExport(variable, 2);
+		if (defun !== scope) {
+			encloseVariable(scope, variable);
+			const found = /** @type {MinifierVariable} */ (
+				findMinifierVariable(scope, name)
+			);
+			if (found !== variable) {
+				identifier.definition = found;
+				this._referenceVariable(identifier, scope, found);
+			}
+		}
+		if (kind === DECLARES_CATCH) {
+			this._addReference(identifier, REFERENCE_CATCH);
+			if (this.legacyCatch) {
+				this.catchNames.push(identifier);
+				this.catchScopes.push(scope);
+			} else {
+				this.catchParameters.push(identifier);
+			}
+		}
+	}
+
+	/**
+	 * @param {PrintNode[]} nodes statements, arguments or a template's segments
+	 * @returns {void}
+	 */
+	_visitList(nodes) {
+		for (let i = 0; i < nodes.length; i++) this._visitPrint(nodes[i]);
+	}
+
+	/**
+	 * Annex B's test for a sloppy block's function: a `var` of its name would be
+	 * an early error, which keeps the function in its block.
+	 * @param {MinifierScope} scope the scope the function is declared in
+	 * @param {string} name the function's name
+	 * @returns {boolean} true for `f` in `{ let f; { function f() {} } }`
+	 */
+	_keepsInBlock(scope, name) {
+		while (scope !== scope.variableScope) {
+			const node = scope.node;
+			switch (node.type) {
+				case "BlockStatement":
+					if (
+						node.body.some((statement) => declaresLexically(statement, name))
+					) {
+						return true;
+					}
+					break;
+				case "SwitchStatement":
+					if (
+						node.cases.some((branch) =>
+							branch.consequent.some((statement) =>
+								declaresLexically(statement, name)
+							)
+						)
+					) {
+						return true;
+					}
+					break;
+				case "ForStatement":
+					if (declaresLexically(node.init, name)) return true;
+					break;
+				case "ForInStatement":
+				case "ForOfStatement":
+					if (declaresLexically(node.left, name)) return true;
+					break;
+				case "CatchClause":
+					// B.3.5 lets a `var` redeclare a plain catch parameter, not a pattern's.
+					// The body's statements sit in this scope, with no block of their own.
+					if (
+						(node.param &&
+							node.param.type !== "Identifier" &&
+							bindsName(node.param, name)) ||
+						node.body.body.some((statement) =>
+							declaresLexically(statement, name)
+						)
+					) {
+						return true;
+					}
+					break;
+			}
+			scope = /** @type {MinifierScope} */ (scope.upper);
+		}
+		const node = scope.node;
+		if (node.type === "Program") {
+			return node.body.some((statement) => declaresLexically(statement, name));
+		}
+		const owner = /** @type {PrintFunction} */ (node);
+		return (
+			owner.params.some((param) => bindsName(param, name)) ||
+			owner.body.body.some((statement) => declaresLexically(statement, name))
+		);
+	}
+
+	/**
+	 * @param {PrintFunction} node a function
+	 * @returns {void}
+	 */
+	_visitMinifierFunction(node) {
+		const outerStrict = this.strict;
+		const outer = /** @type {MinifierScope} */ (this.scope);
+		const outerLabels = this.labelsInScope;
+		const stack = this.stack;
+		const inBlock =
+			node.type === "FunctionDeclaration" &&
+			!isStatementScope(stack[stack.length - 1]);
+		if (inBlock) {
+			this.blockDefunScopes.add(
+				/** @type {MinifierScope} */ (outer.variableScope)
+			);
+		}
+		stack.push(node);
+		const lambda = this._open("function", node, true);
+		if (node.type !== "ArrowFunctionExpression") {
+			this._defineVariable(lambda, null, "arguments", DECLARES_FUNARG);
+		}
+		this.labelsInScope = new Map();
+		const { id } = node;
+		if (!id) {
+			// An arrow or a method has no name of its own.
+		} else if (id.role === "defun") {
+			this._markExport(
+				this._defineVariable(
+					// Annex B hoists a sloppy block's plain function only.
+					this.strict ||
+						(this.parameterScopes &&
+							(node.async ||
+								node.generator ||
+								(inBlock && this._keepsInBlock(outer, id.name))))
+						? outer
+						: /** @type {MinifierScope} */ (outer.variableScope),
+					id,
+					id.name,
+					DECLARES_DEFUN
+				),
+				1
+			);
+		} else {
+			this._defineVariable(lambda, id, id.name, DECLARES_LAMBDA);
+		}
+		if (id && node.type === "FunctionExpression") {
+			lambda.functionName = /** @type {MinifierVariable} */ (id.definition);
+		}
+		const { params } = node;
+		const ranged = this.parameterScopes && params.length !== 0;
+		if (ranged) {
+			lambda.parameterStart = this.referenceNodes.length;
+			this.parameterRanges.push(lambda);
+		}
+		for (let i = 0; i < params.length; i++) {
+			this._visitBinding(params[i], DECLARES_FUNARG);
+		}
+		if (ranged) lambda.parameterEnd = this.referenceNodes.length;
+		if (this.release !== undefined) this.release(node.body);
+		this._visitList(node.body.body);
+		this.scope = outer;
+		this.labelsInScope = outerLabels;
+		this.strict = outerStrict;
+		stack.pop();
+	}
+
+	/**
+	 * @param {PrintClass} node a class
+	 * @returns {void}
+	 */
+	_visitMinifierClass(node) {
+		const outerStrict = this.strict;
+		const outer = /** @type {MinifierScope} */ (this.scope);
+		const outerLabels = this.labelsInScope;
+		this.stack.push(node);
+		this.strict = true;
+		const classScope = this._open("class", node, true);
+		this.labelsInScope = new Map();
+		const { id } = node;
+		if (id) {
+			this._markExport(
+				id.role === "defClass"
+					? this._defineVariable(outer, id, id.name, DECLARES_DEF_CLASS)
+					: this._defineVariable(classScope, id, id.name, DECLARES_CLASS),
+				1
+			);
+		}
+		if (node.superClass) this._visitPrint(node.superClass);
+		this._visitList(node.body.body);
+		this.scope = outer;
+		this.labelsInScope = outerLabels;
+		this.strict = outerStrict;
+		this.stack.pop();
+	}
+
+	/**
+	 * A call under `ie8` or `safari10`, whose catch parameters terser's
+	 * `walk` meets callee first, where its `_walk` meets the arguments first.
+	 * @param {PrintCallExpression | PrintNewExpression} node the call
+	 * @returns {void}
+	 */
+	_visitLegacyCall(node) {
+		const { catchNames, catchScopes } = this;
+		this.stack.push(node);
+		const argumentsStart = catchNames.length;
+		this._visitList(node.arguments);
+		const calleeStart = catchNames.length;
+		this._visitPrint(node.callee);
+		if (argumentsStart < calleeStart && calleeStart < catchNames.length) {
+			catchNames.splice(argumentsStart, 0, ...catchNames.splice(calleeStart));
+			catchScopes.splice(argumentsStart, 0, ...catchScopes.splice(calleeStart));
+		}
+		this.stack.pop();
+	}
+
+	/**
+	 * A loop's children, its scope entered.
+	 * @param {PrintForStatement | PrintForInStatement | PrintForOfStatement | PrintWhileStatement} node the loop
+	 * @returns {void}
+	 */
+	_visitLoop(node) {
+		switch (node.type) {
+			case "ForStatement":
+				if (node.init) this._visitPrint(node.init);
+				if (node.test) this._visitPrint(node.test);
+				if (node.update) this._visitPrint(node.update);
+				break;
+			case "WhileStatement":
+				this._visitPrint(node.test);
+				break;
+			case "DoWhileStatement":
+				this._visitPrint(node.body);
+				this._visitPrint(node.test);
+				return;
+			default:
+				this._visitBinding(node.left, 0);
+				this._visitPrint(node.right);
+		}
+		this._visitPrint(node.body);
+	}
+
+	/**
+	 * @param {PrintVariableDeclaration} node a `var`, `let`, `const` or `using`
+	 * @returns {void}
+	 */
+	_visitDeclaration(node) {
+		const kind =
+			node.kind === "var"
+				? DECLARES_VAR
+				: node.kind === "let"
+					? DECLARES_LET
+					: node.kind === "const"
+						? DECLARES_CONST
+						: DECLARES_USING;
+		const { stack, functionDeclarators, classDeclarators } = this;
+		stack.push(node);
+		const { declarations } = node;
+		for (let i = 0; i < declarations.length; i++) {
+			const declarator = /** @type {PrintVariableDeclarator} */ (
+				declarations[i]
+			);
+			const { id, init } = declarator;
+			if (
+				functionDeclarators !== null &&
+				kind !== DECLARES_USING &&
+				id.type === "Identifier" &&
+				init &&
+				(init.type === "FunctionExpression" ||
+					init.type === "ArrowFunctionExpression") &&
+				!init.id
+			) {
+				functionDeclarators.push(id);
+			} else if (
+				classDeclarators !== null &&
+				kind !== DECLARES_USING &&
+				id.type === "Identifier" &&
+				init &&
+				init.type === "ClassExpression" &&
+				!init.id
+			) {
+				classDeclarators.push(id);
+			}
+			stack.push(declarator);
+			this._visitBinding(id, kind);
+			if (init) this._visitPrint(init);
+			stack.pop();
+		}
+		stack.pop();
+	}
+
+	/**
+	 * @param {Node} node node to visit
+	 * @returns {void}
+	 */
+	_visit(node) {
+		// the shared walk's way back in, for the children of what it reads
+		this._visitPrint(/** @type {PrintNode} */ (/** @type {unknown} */ (node)));
+	}
+
+	/**
+	 * Reads what is scoped as webpack does with the shared walk, pushed as
+	 * terser's walk pushes it, and the rest as terser's analysis does.
+	 * @param {PrintNode} current node to visit
+	 * @returns {void}
+	 */
+	_visitPrint(current) {
+		if (this.release !== undefined) this.release(current);
+		const stack = this.stack;
+		switch (current.type) {
+			case "Identifier": {
+				if (current.atom === true) return;
+				const parent = stack[stack.length - 1];
+				this._addReference(
+					current,
+					current.name === "eval" &&
+						(parent.type === "CallExpression" ||
+							parent.type === "NewExpression")
+						? REFERENCE_CALLED
+						: 0
+				);
+				return;
+			}
+			// the commonest kinds first: the chain is a sequence of comparisons
+			case "MemberExpression":
+				stack.push(current);
+				this._visitPrint(current.object);
+				if (current.computed) {
+					this._visitPrint(current.property);
+				} else if (current.property.type === "PrivateIdentifier") {
+					this.namesPrivate = true;
+				}
+				stack.pop();
+				return;
+			case "CallExpression":
+			case "NewExpression":
+				if (this.legacyCatch) {
+					this._visitLegacyCall(current);
+					return;
+				}
+				// terser's walk reaches the arguments first.
+				stack.push(current);
+				this._visitList(current.arguments);
+				this._visitPrint(current.callee);
+				stack.pop();
+				return;
+			case "Literal":
+			case "ThisExpression":
+				return;
+			case "ExpressionStatement":
+				if (typeof current.directive === "string") {
+					if (current.directive === "use strict") this.strict = true;
+					return;
+				}
+				stack.push(current);
+				this._visitPrint(current.expression);
+				stack.pop();
+				return;
+			case "BinaryExpression":
+			case "LogicalExpression":
+			case "AssignmentExpression":
+				stack.push(current);
+				this._visitPrint(current.left);
+				this._visitPrint(current.right);
+				stack.pop();
+				return;
+			case "BlockStatement": {
+				stack.push(current);
+				const outer = this._enterBlock("block", current);
+				this._visitList(current.body);
+				this.scope = outer;
+				stack.pop();
+				return;
+			}
+			case "ReturnStatement":
+			case "UnaryExpression":
+			case "UpdateExpression":
+			case "ThrowStatement":
+			case "AwaitExpression":
+			case "SpreadElement":
+			case "YieldExpression":
+				stack.push(current);
+				if (current.argument) this._visitPrint(current.argument);
+				stack.pop();
+				return;
+			case "VariableDeclaration":
+				this._visitDeclaration(current);
+				return;
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+				this._visitMinifierFunction(current);
+				return;
+			case "ClassDeclaration":
+			case "ClassExpression":
+				this._visitMinifierClass(current);
+				return;
+			case "ForStatement":
+			case "ForInStatement":
+			case "ForOfStatement":
+			case "WhileStatement":
+			case "DoWhileStatement": {
+				stack.push(current);
+				const outer = this._enterBlock(
+					current.type.startsWith("For") ? "for" : "block",
+					current
+				);
+				if (this.safari10 && current.type.startsWith("For")) {
+					this.forScopes.push(/** @type {MinifierScope} */ (this.scope));
+				}
+				this._visitLoop(current);
+				this.scope = outer;
+				stack.pop();
+				return;
+			}
+			case "SwitchStatement": {
+				stack.push(current);
+				const outer = this._enterBlock("switch", current);
+				// The switched expression belongs to the scope around the switch.
+				const block = this.scope;
+				this.scope = outer;
+				this._visitPrint(current.discriminant);
+				this.scope = block;
+				this._visitList(current.cases);
+				this.scope = outer;
+				stack.pop();
+				return;
+			}
+			case "CatchClause": {
+				stack.push(current);
+				const outer = this._enterBlock("catch", current);
+				const catchScope = /** @type {MinifierScope} */ (this.scope);
+				const ranged = this.parameterScopes && Boolean(current.param);
+				if (ranged) {
+					catchScope.parameterStart = this.referenceNodes.length;
+					this.parameterRanges.push(catchScope);
+				}
+				if (current.param) this._visitBinding(current.param, DECLARES_CATCH);
+				if (ranged) catchScope.parameterEnd = this.referenceNodes.length;
+				if (this.release !== undefined) this.release(current.body);
+				this._visitList(current.body.body);
+				this.scope = outer;
+				stack.pop();
+				return;
+			}
+			case "StaticBlock": {
+				const outer = this.scope;
+				const outerLabels = this.labelsInScope;
+				stack.push(current);
+				this._open("class-static-block", current, true);
+				this.labelsInScope = new Map();
+				this._visitList(current.body);
+				this.scope = outer;
+				this.labelsInScope = outerLabels;
+				stack.pop();
+				return;
+			}
+			case "LabeledStatement": {
+				const labelName = /** @type {PrintIdentifier} */ (current.label);
+				const { name } = labelName;
+				if (this.labelsInScope.has(name)) {
+					throw new Error(`Label ${name} defined twice`);
+				}
+				const label = new MinifierLabel(name, this.currentLabel);
+				this.labels.push(label);
+				if (this.release !== undefined) this.release(labelName);
+				labelName.definition = label;
+				this.labelsInScope.set(name, label);
+				stack.push(current);
+				this.currentLabel = label;
+				this._visitPrint(current.body);
+				this.currentLabel = label.parent;
+				stack.pop();
+				this.labelsInScope.delete(name);
+				return;
+			}
+			case "BreakStatement":
+			case "ContinueStatement": {
+				const name = /** @type {PrintIdentifier | null} */ (current.label);
+				if (!name) return;
+				const label = this.labelsInScope.get(name.name);
+				if (label === undefined) {
+					const start = /** @type {Token} */ (this.tokenOf(name.startToken));
+					throw new Error(
+						`Undefined label ${name.name} [${start.line},${start.col}]`
+					);
+				}
+				if (this.release !== undefined) this.release(name);
+				name.definition = label;
+				return;
+			}
+			case "WithStatement":
+				for (
+					let outer = /** @type {MinifierScope | null} */ (this.scope);
+					outer !== null;
+					outer = /** @type {MinifierScope | null} */ (outer.upper)
+				) {
+					outer.usesWith = true;
+				}
+				stack.push(current);
+				this._visitPrint(current.object);
+				this._visitPrint(current.body);
+				stack.pop();
+				return;
+			case "Property":
+			case "PropertyDefinition":
+				if (current.key.type === "PrivateIdentifier") this.namesPrivate = true;
+				stack.push(current);
+				if (current.computed) this._visitPrint(current.key);
+				if (current.value) this._visitPrint(current.value);
+				if (
+					current.type === "Property" &&
+					current.kind === "init" &&
+					!current.method
+				) {
+					this._spellProperty(current);
+				}
+				stack.pop();
+				return;
+			case "ObjectPattern":
+			case "ArrayPattern":
+			case "AssignmentPattern":
+			case "RestElement":
+				this._visitBinding(current, 0);
+				return;
+			case "TemplateLiteral":
+				stack.push(current);
+				this._visitList(current.segments);
+				stack.pop();
+				return;
+			case "ImportExpression":
+				stack.push(current);
+				this._visitList(current.args);
+				stack.pop();
+				return;
+			case "MethodDefinition":
+				if (current.key.type === "PrivateIdentifier") this.namesPrivate = true;
+			// falls through
+			case "IfStatement":
+			case "ConditionalExpression":
+			case "SwitchCase":
+			case "ArrayExpression":
+			case "ObjectExpression":
+			case "SequenceExpression":
+			case "TaggedTemplateExpression":
+			case "ChainExpression":
+			case "TryStatement":
+				// scoped alike, so read by the shared walk, pushed as terser's walk does
+				stack.push(current);
+				super._visit(/** @type {Node} */ (/** @type {unknown} */ (current)));
+				stack.pop();
+				return;
+			case "PrivateIdentifier":
+				this.namesPrivate = true;
+				return;
+			case "Super":
+			case "EmptyStatement":
+			case "DebuggerStatement":
+			case "MetaProperty":
+			case "TemplateElement":
+				return;
+			case "ImportDeclaration": {
+				this._checkModuleStatement(current, "Import");
+				stack.push(current);
+				// terser holds a default import's name with no node around it.
+				if (current.imported_name) {
+					this._declare(current.imported_name, DECLARES_IMPORT);
+				}
+				const names = current.imported_names;
+				if (names) {
+					for (let i = 0; i < names.length; i++) {
+						const specifier = names[i];
+						stack.push(specifier);
+						this._declare(
+							/** @type {PrintIdentifier} */ (specifier.local),
+							DECLARES_IMPORT
+						);
+						if (specifier.type === "ImportSpecifier") {
+							this._spell(specifier.local, specifier.imported, AS_SAVING);
+						}
+						stack.pop();
+					}
+				}
+				stack.pop();
+				return;
+			}
+			case "ExportNamedDeclaration": {
+				this._checkModuleStatement(current, "Export");
+				stack.push(current);
+				const declaration =
+					current.exported_value || current.exported_definition;
+				if (declaration) this._visitPrint(declaration);
+				const fromModule = Boolean(current.source);
+				const specifiers = current.exported_names;
+				if (specifiers) {
+					for (let i = 0; i < specifiers.length; i++) {
+						const specifier = specifiers[i];
+						stack.push(specifier);
+						this._addReference(
+							/** @type {PrintIdentifier | PrintLiteral} */ (specifier.local),
+							fromModule
+								? REFERENCE_EXPORTED | REFERENCE_FROM_MODULE
+								: REFERENCE_EXPORTED
+						);
+						if (!fromModule) {
+							this._spell(specifier.local, specifier.exported, AS_SAVING);
+						}
+						stack.pop();
+					}
+				}
+				stack.pop();
+				return;
+			}
+			case "ExportDefaultDeclaration":
+				this._checkModuleStatement(current, "Export");
+				stack.push(current);
+				this._visitPrint(
+					/** @type {PrintNode} */ (
+						current.exported_value || current.exported_definition
+					)
+				);
+				stack.pop();
+				return;
+			case "ExportAllDeclaration":
+				// terser's `*` reads a global no name in the output depends on.
+				this._checkModuleStatement(current, "Export");
+				return;
+			default:
+				throw new Error(
+					`The minifier's scope analysis cannot read a ${current.type} node`
+				);
+		}
+	}
+
+	/**
+	 * Drops the ranges of parameter reads this analysis counted.
+	 * @returns {void}
+	 */
+	_clearParameterRanges() {
+		const { parameterRanges } = this;
+		for (let i = 0; i < parameterRanges.length; i++) {
+			parameterRanges[i].parameterStart = -1;
+			parameterRanges[i].parameterEnd = -1;
+		}
+		parameterRanges.length = 0;
+	}
+
+	/**
+	 * Resolves each name read, finds `eval`, and encloses what a catch
+	 * parameter redefines, then moves the catch parameters old engines scope
+	 * to their function.
+	 * @returns {void}
+	 */
+	_resolveMinifier() {
+		const { referenceNodes, referenceScopes, referenceFlags, globals } = this;
+		for (let i = 0; i < referenceNodes.length; i++) {
+			const node = referenceNodes[i];
+			const from = referenceScopes[i];
+			const flags = referenceFlags[i];
+			if (flags & REFERENCE_CATCH) {
+				// The definition a catch parameter redefines in its function's scope.
+				const redefinition = /** @type {MinifierVariable | undefined} */ (
+					from.variableScope.getBinding(
+						/** @type {PrintIdentifier} */ (node).name
+					)
+				);
+				if (redefinition !== undefined) encloseVariable(from, redefinition);
+				continue;
+			}
+			const { name } = node;
+			if (flags & REFERENCE_CALLED) {
+				for (
+					let outer = /** @type {MinifierScope | null} */ (from);
+					outer !== null && !outer.usesEval;
+					outer = /** @type {MinifierScope | null} */ (outer.upper)
+				) {
+					outer.usesEval = true;
+				}
+			}
+			let variable =
+				flags & REFERENCE_FROM_MODULE
+					? undefined
+					: findMinifierVariable(from, name, i);
+			if (variable === undefined) {
+				variable = globals.get(name);
+				if (variable === undefined) {
+					variable = new MinifierVariable(name, this.toplevel, DECLARES_GLOBAL);
+					variable.undeclared = true;
+					variable.global = true;
+					globals.set(name, variable);
+				}
+				if (flags & REFERENCE_EXPORTED) variable.export = EXPORT_KEEP_NAME;
+			}
+			if (node.type === "Identifier") {
+				node.definition = variable;
+				this._referenceVariable(node, from, variable);
+			} else {
+				// A re-exported string reads a global, which keeps no references.
+				encloseVariable(from, variable);
+			}
+		}
+
+		this._clearParameterRanges();
+
+		// Passes 3 and 4: work around old engines' catch and loop scopes.
+		const { catchNames, catchScopes } = this;
+		for (let i = 0; i < catchNames.length; i++) {
+			const identifier = catchNames[i];
+			const { name } = identifier;
+			const references = /** @type {MinifierVariable} */ (identifier.definition)
+				.references;
+			const defunScope = /** @type {MinifierScope} */ (
+				catchScopes[i].variableScope
+			);
+			const variable =
+				findMinifierVariable(defunScope, name) ||
+				globals.get(name) ||
+				this._defineVariable(defunScope, null, name, DECLARES_CATCH);
+			// As terser's `forEach`: referencing appends to the list it reads.
+			const { length } = references;
+			for (let j = 0; j < length; j++) {
+				const read = /** @type {PrintIdentifier} */ (
+					/** @type {unknown} */ (references[j].identifier)
+				);
+				read.definition = variable;
+				this._referenceVariable(
+					read,
+					/** @type {MinifierScope} */ (references[j].from),
+					variable
+				);
+			}
+			identifier.definition = variable;
+			this._referenceVariable(identifier, catchScopes[i], variable);
+		}
+		const { forScopes } = this;
+		for (let i = 0; i < forScopes.length; i++) {
+			const forScope = forScopes[i];
+			const variables = /** @type {MinifierScope} */ (forScope.upper).variables;
+			for (let j = 0; j < variables.length; j++) {
+				encloseUnique(forScope, /** @type {MinifierVariable} */ (variables[j]));
+			}
+		}
+	}
+}
+
+/**
+ * Analyses the minifier's tree with terser's scoping, which the names it
+ * hands out depend on: see `MinifierScopeAnalyzer`.
+ * @param {PrintProgram} program the tree, its names as written
+ * @param {MinifierScopeOptions} options the mangle options
+ * @param {(node: PrintNode, message: string, tables?: TokenTables) => never} raise throws the parse error a misplaced declaration is
+ * @param {((node: PrintNode) => void)=} release drops what only the compressor read off each node read, where nobody keeps the tree
+ * @returns {MinifierScopeAnalysis} the scopes
+ */
+const analyzeMinifierScope = (program, options, raise, release) => {
+	const analyzer = new MinifierScopeAnalyzer(program, options, raise, release);
+	if (release !== undefined) release(program);
+	analyzer.stack.push(program);
+	analyzer._visitList(program.body);
+	analyzer.stack.pop();
+	analyzer._resolveMinifier();
+	return {
+		toplevel: analyzer.toplevel,
+		labels: analyzer.labels,
+		globals: analyzer.globals,
+		blockDefunScopes: analyzer.blockDefunScopes,
+		functionDeclarators: analyzer.functionDeclarators,
+		classDeclarators: analyzer.classDeclarators,
+		catchParameters: analyzer.catchParameters,
+		namesPrivate: analyzer.namesPrivate,
+		spelledNames: analyzer.spelledNames
+	};
+};
+
+/**
+ * @typedef {import("./syntax-parser").SyntaxTree} SyntaxTree
+ * @typedef {MinifierVariable | MinifierLabel | null} TreeDefinition
+ */
+
+/**
+ * The scopes the minifier's analysis reads off a `SyntaxTree`: each name's
+ * definition is held by its node's number.
+ * @typedef {MinifierScopeAnalysis & { definitions: TreeDefinition[] }} MinifierTreeScopeAnalysis
+ */
+
+// The tree's tables, read when a first tree is analysed: wherever webpack
+// reads a scope, requiring them would load the parser's data too.
+/** @type {typeof import("./data").NodeType} */
+let NodeType;
+/** @type {typeof import("./data").Field} */
+let Field;
+/** @type {typeof import("./data").Flag} */
+let Flag;
+/** @type {typeof import("./data").Part} */
+let Part;
+
+/**
+ * `MinifierScopeAnalyzer` over a `SyntaxTree` of the source terser's tree
+ * was read from: the same walk, pushing the same nodes, so the same scopes,
+ * definitions and orders. Neither `ie8` nor `safari10` is read.
+ */
+class MinifierTreeScopeAnalyzer {
+	/**
+	 * @param {SyntaxTree} tree the tree
+	 * @param {number} program its program
+	 * @param {Uint8Array} types each node's type, as terser's tree types it
+	 * @param {MinifierScopeOptions} options the mangle options
+	 * @param {(node: number, message: string) => never} raise throws the parse error a misplaced import or export is
+	 */
+	constructor(tree, program, types, options, raise) {
+		/** @type {SyntaxTree} */
+		this.tree = tree;
+		/** @type {Uint8Array} */
+		this.types = types;
+		/** @type {(node: number, message: string) => never} */
+		this.raise = raise;
+		/** @type {boolean} */
+		this.parameterScopes = Boolean(options.parameterScopes);
+		/** @type {MinifierScope[]} */
+		this.parameterRanges = [];
+		/** @type {MinifierScope} */
+		this.toplevel = new MinifierScope(
+			"global",
+			/** @type {PrintNode} */ (/** @type {unknown} */ (program)),
+			null,
+			true
+		);
+		/** @type {MinifierScope} */
+		this.scope = this.toplevel;
+		/** @type {MinifierLabel[]} */
+		this.labels = [];
+		/** @type {Map<string, MinifierVariable>} */
+		this.globals = new Map();
+		/** @type {Set<MinifierScope>} */
+		this.blockDefunScopes = new Set();
+		/** @type {number[] | null} */
+		this.functionDeclarators = options.keep_fnames ? [] : null;
+		/** @type {number[] | null} */
+		this.classDeclarators =
+			options.classDeclarators && options.keep_classnames ? [] : null;
+		/** @type {number[]} */
+		this.referenceNodes = [];
+		/** @type {MinifierScope[]} */
+		this.referenceScopes = [];
+		/** @type {number[]} */
+		this.referenceFlags = [];
+		/** @type {number[]} */
+		this.catchParameters = [];
+		/** @type {boolean} */
+		this.namesPrivate = false;
+		/** @type {number[]} the nodes terser's walk has pushed, 0 for an arrow's implicit `return` */
+		this.stack = [];
+		/** @type {boolean} */
+		this.strict = Boolean(options.module);
+		/** @type {Map<string, MinifierLabel>} */
+		this.labelsInScope = new Map();
+		/** @type {MinifierLabel | null} */
+		this.currentLabel = null;
+		/** @type {number} the pattern the walk is inside, 0 for none */
+		this.inDestructuring = 0;
+		// Filled in place: `Array.from` takes four times as long on a large tree.
+		/** @type {TreeDefinition[]} */
+		// eslint-disable-next-line unicorn/no-new-array
+		this.definitions = new Array(types.length).fill(null);
+		/** @type {number[] | null} each name with one spelled beside it */
+		this.spelledIdentifiers = options.spelledNames ? [] : null;
+		/** @type {string[]} the name spelled beside each */
+		this.spellings = [];
+		/** @type {number[]} the characters each pair saves */
+		this.spelledSavings = [];
+		/** @type {boolean} whether a key spells a name, which prints alone where it is its value's */
+		this.spelledKeys = options.spelledNames === SPELLED_KEYS;
+	}
+
+	/**
+	 * Collects a name and one spelled beside it, under `spelledNames`.
+	 * @param {number} identifier the name, 0 for none
+	 * @param {number} spelled what spells the other, 0 for none
+	 * @param {number} saving the characters it saves taking that name
+	 * @returns {void}
+	 */
+	_spell(identifier, spelled, saving) {
+		const identifiers = this.spelledIdentifiers;
+		const { types, tree } = this;
+		if (
+			identifiers === null ||
+			identifier === 0 ||
+			spelled === 0 ||
+			types[identifier] !== NodeType.Identifier
+		) {
+			return;
+		}
+		/** @type {unknown} */
+		let spelling;
+		if (types[spelled] === NodeType.Identifier) {
+			spelling = tree.name(spelled);
+		} else if (types[spelled] === NodeType.Literal) {
+			spelling = tree.value(spelled);
+		}
+		if (
+			typeof spelling !== "string" ||
+			!SPELLABLE_NAME.test(spelling) ||
+			NAMES_NO_BINDING_TAKES.has(spelling) ||
+			// A shorthand `__proto__` is an own property; `__proto__:` sets the prototype.
+			spelling === "__proto__"
+		) {
+			return;
+		}
+		identifiers.push(identifier);
+		this.spellings.push(spelling);
+		this.spelledSavings.push(saving);
+	}
+
+	/**
+	 * Collects a property's value named as its key could be, under `spelledNames`.
+	 * @param {number} property a property of an object or a pattern
+	 * @returns {void}
+	 */
+	_spellProperty(property) {
+		const { tree } = this;
+		if (!this.spelledKeys || tree.flag(Flag.computed, property)) {
+			return;
+		}
+		const value = tree.field(0, Field.value, property);
+		this._spell(
+			this.types[value] === NodeType.AssignmentPattern
+				? tree.field(0, Field.left, value)
+				: value,
+			tree.field(0, Field.key, property),
+			SHORTHAND_SAVING
+		);
+	}
+
+	/**
+	 * @returns {SpelledNames | null} the names collected under `spelledNames`, resolved
+	 */
+	_spelledNames() {
+		const identifiers = this.spelledIdentifiers;
+		if (identifiers === null) return null;
+		return {
+			identifiers: this._asNames(identifiers),
+			spellings: this.spellings,
+			savings: this.spelledSavings
+		};
+	}
+
+	/**
+	 * @param {number} field the `Field`
+	 * @param {number} node a node
+	 * @param {number=} i the item's index, for a list
+	 * @returns {number} the node the field holds, past parentheses, 0 for none
+	 */
+	_child(field, node, i = 0) {
+		const { tree } = this;
+		let child = tree.field(i, field, node);
+		while (
+			child !== 0 &&
+			tree.type(child) === NodeType.ParenthesizedExpression
+		) {
+			child = tree.field(0, Field.expression, child);
+		}
+		return child;
+	}
+
+	/**
+	 * @param {number} field the `Field`, a list
+	 * @param {number} node a node
+	 * @returns {void}
+	 */
+	_visitList(field, node) {
+		const count = this.tree.fieldCount(field, node);
+		for (let i = 0; i < count; i++) {
+			const child = this._child(field, node, i);
+			if (child !== 0) this._visit(child);
+		}
+	}
+
+	/**
+	 * @param {number} field the `Field`
+	 * @param {number} node a node
+	 * @returns {void}
+	 */
+	_visitChild(field, node) {
+		const child = this._child(field, node);
+		if (child !== 0) this._visit(child);
+	}
+
+	/**
+	 * @param {number} node a node
+	 * @returns {string} the name it is, a quoted module name's among them
+	 */
+	_nameOf(node) {
+		const { tree } = this;
+		return tree.type(node) === NodeType.Literal
+			? String(tree.value(node))
+			: tree.name(node);
+	}
+
+	/**
+	 * @param {ScopeType} type what opens it
+	 * @param {number} node the node opening it
+	 * @param {boolean} isVarScope whether `var` hoists to here
+	 * @returns {MinifierScope} the scope, now current
+	 */
+	_open(type, node, isVarScope) {
+		const scope = new MinifierScope(
+			type,
+			/** @type {PrintNode} */ (/** @type {unknown} */ (node)),
+			this.scope,
+			isVarScope
+		);
+		this.scope = scope;
+		return scope;
+	}
+
+	/**
+	 * @param {ScopeType} type what opens it
+	 * @param {number} node a block's node
+	 * @returns {MinifierScope} the scope it leaves
+	 */
+	_enterBlock(type, node) {
+		const outer = this.scope;
+		this._open(type, node, false).usesWith = outer.usesWith;
+		return outer;
+	}
+
+	/**
+	 * terser's `def_variable`.
+	 * @param {MinifierScope} target the scope declaring it
+	 * @param {number} identifier the name declaring it, 0 for none written
+	 * @param {string} name the name
+	 * @param {number} kind how it is declared
+	 * @returns {MinifierVariable} its definition, made or joined
+	 */
+	_defineVariable(target, identifier, name, kind) {
+		let variable = /** @type {MinifierVariable | undefined} */ (
+			target.getBinding(name)
+		);
+		if (variable !== undefined) {
+			variable.declarations |= 1 << kind;
+		} else {
+			variable = new MinifierVariable(name, target, kind);
+			variable.global = target.upper === null;
+			addBinding(target, variable);
+		}
+		if (identifier !== 0) this.definitions[identifier] = variable;
+		return variable;
+	}
+
+	/**
+	 * @param {MinifierScope} from the scope reading it
+	 * @param {MinifierVariable} variable what it reads
+	 * @returns {void}
+	 */
+	_referenceVariable(from, variable) {
+		variable.referenceCount++;
+		encloseVariable(from, variable);
+	}
+
+	/**
+	 * terser's `mark_export`, counting levels on the walk's stack.
+	 * @param {MinifierVariable} variable a definition just made
+	 * @param {number} level where its declaration's statement is
+	 * @returns {void}
+	 */
+	_markExport(variable, level) {
+		const { stack } = this;
+		if (this.inDestructuring !== 0) {
+			let i = 0;
+			do {
+				level++;
+			} while (stack[stack.length - 1 - i++] !== this.inDestructuring);
+		}
+		const node = stack[stack.length - 1 - level];
+		const type = node === undefined ? 0 : this.types[node];
+		if (
+			type !== NodeType.ExportNamedDeclaration &&
+			type !== NodeType.ExportDefaultDeclaration &&
+			type !== NodeType.ExportAllDeclaration
+		) {
+			variable.export = 0;
+			return;
+		}
+		variable.export =
+			type === NodeType.ExportDefaultDeclaration && !this._exportsValue(node)
+				? EXPORT_WANT_MANGLE
+				: EXPORT_KEEP_NAME;
+	}
+
+	/**
+	 * @param {number} node an `export default`
+	 * @returns {boolean} whether terser holds what it exports as a value, not a named declaration
+	 */
+	_exportsValue(node) {
+		const declaration = this.tree.field(0, Field.declaration, node);
+		const type = this.tree.type(declaration);
+		return (
+			(type !== NodeType.FunctionDeclaration &&
+				type !== NodeType.ClassDeclaration) ||
+			this.tree.field(0, Field.id, declaration) === 0
+		);
+	}
+
+	/**
+	 * @param {number} node an import or export
+	 * @param {string} type terser's name for it
+	 * @returns {void}
+	 */
+	_checkModuleStatement(node, type) {
+		if (this.scope !== this.toplevel) {
+			this.raise(node, `"${type}" statement may only appear at the top level`);
+		}
+	}
+
+	/**
+	 * @param {number} node a name read, or a re-exported string
+	 * @param {number} flags what else is known of it, as `REFERENCE_*` bits
+	 * @returns {void}
+	 */
+	_addReference(node, flags) {
+		this.referenceNodes.push(node);
+		this.referenceScopes.push(this.scope);
+		this.referenceFlags.push(flags);
+	}
+
+	/**
+	 * A name a declaration or a pattern binds, or reads where `kind` is 0.
+	 * @param {number} node the name or pattern
+	 * @param {number} kind how it declares, as a `DECLARES_*` code, or 0
+	 * @returns {void}
+	 */
+	_visitBinding(node, kind) {
+		const { stack } = this;
+		switch (this.types[node]) {
+			case NodeType.Identifier:
+				if (kind === 0) this._visit(node);
+				else this._declare(node, kind);
+				return;
+			case NodeType.ObjectPattern:
+				this._visitPattern(node, Field.properties, kind);
+				return;
+			case NodeType.ArrayPattern:
+				this._visitPattern(node, Field.elements, kind);
+				return;
+			case NodeType.AssignmentPattern:
+				stack.push(node);
+				this._visitBinding(this._child(Field.left, node), kind);
+				this._visit(this._child(Field.right, node));
+				stack.pop();
+				return;
+			case NodeType.RestElement:
+				stack.push(node);
+				this._visitBinding(this._child(Field.argument, node), kind);
+				stack.pop();
+				return;
+			default:
+				this._visit(node);
+		}
+	}
+
+	/**
+	 * @param {number} pattern an object or array pattern
+	 * @param {number} field its properties or elements
+	 * @param {number} kind how it declares, as a `DECLARES_*` code, or 0
+	 * @returns {void}
+	 */
+	_visitPattern(pattern, field, kind) {
+		const { stack, tree } = this;
+		const outer = this.inDestructuring;
+		this.inDestructuring = pattern;
+		stack.push(pattern);
+		const count = tree.fieldCount(field, pattern);
+		for (let i = 0; i < count; i++) {
+			const element = this._child(field, pattern, i);
+			if (element === 0) continue;
+			if (this.types[element] !== NodeType.Property) {
+				this._visitBinding(element, kind);
+				continue;
+			}
+			stack.push(element);
+			if (tree.flag(Flag.computed, element)) {
+				this._visitChild(Field.key, element);
+			}
+			this._visitBinding(this._child(Field.value, element), kind);
+			this._spellProperty(element);
+			stack.pop();
+		}
+		stack.pop();
+		this.inDestructuring = outer;
+	}
+
+	/**
+	 * A `var`, parameter, `let`, `const`, `using`, catch parameter or import.
+	 * @param {number} identifier the name declared
+	 * @param {number} kind how, as a `DECLARES_*` code
+	 * @returns {void}
+	 */
+	_declare(identifier, kind) {
+		const name = this.tree.name(identifier);
+		const { scope } = this;
+		if (kind === DECLARES_IMPORT) {
+			this._defineVariable(scope, identifier, name, kind);
+			return;
+		}
+		const blockDeclaration =
+			kind === DECLARES_LET ||
+			kind === DECLARES_CONST ||
+			kind === DECLARES_USING ||
+			kind === DECLARES_CATCH;
+		const defun = /** @type {MinifierScope} */ (scope.variableScope);
+		// A redeclaration terser refuses here the tree's parser refused first.
+		const variable = this._defineVariable(
+			blockDeclaration ? scope : defun,
+			identifier,
+			name,
+			kind
+		);
+		if (kind !== DECLARES_FUNARG) this._markExport(variable, 2);
+		if (defun !== scope) {
+			encloseVariable(scope, variable);
+			const found = /** @type {MinifierVariable} */ (
+				findMinifierVariable(scope, name)
+			);
+			if (found !== variable) {
+				this.definitions[identifier] = found;
+				this._referenceVariable(scope, found);
+			}
+		}
+		if (kind === DECLARES_CATCH) {
+			this._addReference(identifier, REFERENCE_CATCH);
+			this.catchParameters.push(identifier);
+		}
+	}
+
+	/**
+	 * @param {number} node a binding pattern, 0 for an array's hole
+	 * @param {string} name a name
+	 * @returns {boolean} whether the pattern binds the name
+	 */
+	_bindsName(node, name) {
+		if (node === 0) return false;
+		const { tree } = this;
+		switch (this.types[node]) {
+			case NodeType.ObjectPattern:
+				return this._someChild(Field.properties, node, (property) =>
+					this._bindsName(
+						this.types[property] === NodeType.Property
+							? this._child(Field.value, property)
+							: property,
+						name
+					)
+				);
+			case NodeType.ArrayPattern:
+				return this._someChild(Field.elements, node, (element) =>
+					this._bindsName(element, name)
+				);
+			case NodeType.AssignmentPattern:
+				return this._bindsName(this._child(Field.left, node), name);
+			case NodeType.RestElement:
+				return this._bindsName(this._child(Field.argument, node), name);
+			default:
+				return tree.name(node) === name;
+		}
+	}
+
+	/**
+	 * @param {number} field the `Field`, a list
+	 * @param {number} node a node
+	 * @param {(child: number) => boolean} test what a child is asked
+	 * @returns {boolean} whether it holds for a child, holes 0
+	 */
+	_someChild(field, node, test) {
+		const count = this.tree.fieldCount(field, node);
+		for (let i = 0; i < count; i++) {
+			if (test(this._child(field, node, i))) return true;
+		}
+		return false;
+	}
+
+	/**
+	 * @param {number} node a statement, or a loop's head, 0 for none
+	 * @param {string} name a name
+	 * @returns {boolean} whether it declares the name with `let`, `const`, `using` or a class
+	 */
+	_declaresLexically(node, name) {
+		if (node === 0) return false;
+		const { tree } = this;
+		const type = this.types[node];
+		if (type === NodeType.VariableDeclaration) {
+			return (
+				tree.textOf(Part.kind, node) !== "var" &&
+				this._someChild(Field.declarations, node, (declarator) =>
+					this._bindsName(tree.field(0, Field.id, declarator), name)
+				)
+			);
+		}
+		return (
+			type === NodeType.ClassDeclaration &&
+			tree.name(tree.field(0, Field.id, node)) === name
+		);
+	}
+
+	/**
+	 * @param {number} owner a node listing statements
+	 * @param {number} field the `Field` listing them
+	 * @param {string} name a name
+	 * @returns {boolean} whether one of them declares it lexically
+	 */
+	_listDeclaresLexically(owner, field, name) {
+		const count = this.tree.fieldCount(field, owner);
+		for (let i = 0; i < count; i++) {
+			if (this._declaresLexically(this.tree.field(i, field, owner), name)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Annex B's test for a sloppy block's function: a `var` of its name would be
+	 * an early error, which keeps the function in its block.
+	 * @param {MinifierScope} scope the scope the function is declared in
+	 * @param {string} name the function's name
+	 * @returns {boolean} true for `f` in `{ let f; { function f() {} } }`
+	 */
+	_keepsInBlock(scope, name) {
+		const { tree } = this;
+		while (scope !== scope.variableScope) {
+			const node = /** @type {number} */ (/** @type {unknown} */ (scope.node));
+			switch (this.types[node]) {
+				case NodeType.BlockStatement:
+					if (this._listDeclaresLexically(node, Field.body, name)) return true;
+					break;
+				case NodeType.SwitchStatement: {
+					const count = tree.fieldCount(Field.cases, node);
+					for (let i = 0; i < count; i++) {
+						const branch = tree.field(i, Field.cases, node);
+						if (this._listDeclaresLexically(branch, Field.consequent, name)) {
+							return true;
+						}
+					}
+					break;
+				}
+				case NodeType.ForStatement:
+					if (this._declaresLexically(this._child(Field.init, node), name)) {
+						return true;
+					}
+					break;
+				case NodeType.ForInStatement:
+				case NodeType.ForOfStatement:
+					if (this._declaresLexically(this._child(Field.left, node), name)) {
+						return true;
+					}
+					break;
+				case NodeType.CatchClause: {
+					const param = tree.field(0, Field.param, node);
+					if (
+						(param !== 0 &&
+							this.types[param] !== NodeType.Identifier &&
+							this._bindsName(param, name)) ||
+						this._listDeclaresLexically(
+							tree.field(0, Field.body, node),
+							Field.body,
+							name
+						)
+					) {
+						return true;
+					}
+					break;
+				}
+			}
+			scope = /** @type {MinifierScope} */ (scope.upper);
+		}
+		const node = /** @type {number} */ (/** @type {unknown} */ (scope.node));
+		if (this.types[node] === NodeType.Program) {
+			return this._listDeclaresLexically(node, Field.body, name);
+		}
+		// A function holding a statement has a block for its body.
+		return (
+			this._someChild(Field.params, node, (param) =>
+				this._bindsName(param, name)
+			) ||
+			this._listDeclaresLexically(
+				this._child(Field.body, node),
+				Field.body,
+				name
+			)
+		);
+	}
+
+	/**
+	 * @param {number} node a function
+	 * @returns {void}
+	 */
+	_visitFunction(node) {
+		const { stack, tree } = this;
+		const outerStrict = this.strict;
+		const outer = this.scope;
+		const outerLabels = this.labelsInScope;
+		const type = this.types[node];
+		const parentType = this.types[stack[stack.length - 1]];
+		const inBlock =
+			type === NodeType.FunctionDeclaration &&
+			parentType !== NodeType.Program &&
+			parentType !== NodeType.FunctionDeclaration &&
+			parentType !== NodeType.FunctionExpression &&
+			parentType !== NodeType.ArrowFunctionExpression &&
+			parentType !== NodeType.StaticBlock;
+		if (inBlock) {
+			this.blockDefunScopes.add(
+				/** @type {MinifierScope} */ (outer.variableScope)
+			);
+		}
+		stack.push(node);
+		const lambda = this._open("function", node, true);
+		if (type !== NodeType.ArrowFunctionExpression) {
+			this._defineVariable(lambda, 0, "arguments", DECLARES_FUNARG);
+		}
+		this.labelsInScope = new Map();
+		const id = tree.field(0, Field.id, node);
+		if (id === 0) {
+			// An arrow or a method has no name of its own.
+		} else if (type === NodeType.FunctionDeclaration) {
+			const name = tree.name(id);
+			this._markExport(
+				this._defineVariable(
+					// Annex B hoists a sloppy block's plain function only.
+					this.strict ||
+						(this.parameterScopes &&
+							(tree.flag(Flag.async, node) ||
+								tree.flag(Flag.generator, node) ||
+								(inBlock && this._keepsInBlock(outer, name))))
+						? outer
+						: /** @type {MinifierScope} */ (outer.variableScope),
+					id,
+					name,
+					DECLARES_DEFUN
+				),
+				1
+			);
+		} else {
+			this._defineVariable(lambda, id, tree.name(id), DECLARES_LAMBDA);
+			lambda.functionName = /** @type {MinifierVariable} */ (
+				this.definitions[id]
+			);
+		}
+		const params = tree.fieldCount(Field.params, node);
+		const ranged = this.parameterScopes && params !== 0;
+		if (ranged) {
+			lambda.parameterStart = this.referenceNodes.length;
+			this.parameterRanges.push(lambda);
+		}
+		for (let i = 0; i < params; i++) {
+			this._visitBinding(this._child(Field.params, node, i), DECLARES_FUNARG);
+		}
+		if (ranged) lambda.parameterEnd = this.referenceNodes.length;
+		const body = this._child(Field.body, node);
+		if (this.types[body] === NodeType.BlockStatement) {
+			this._visitList(Field.body, body);
+		} else {
+			// terser's arrow returns its expression from a statement of its own.
+			stack.push(0);
+			this._visit(body);
+			stack.pop();
+		}
+		this.scope = outer;
+		this.labelsInScope = outerLabels;
+		this.strict = outerStrict;
+		stack.pop();
+	}
+
+	/**
+	 * @param {number} node a class
+	 * @returns {void}
+	 */
+	_visitClass(node) {
+		const { tree } = this;
+		const outerStrict = this.strict;
+		const outer = this.scope;
+		const outerLabels = this.labelsInScope;
+		this.stack.push(node);
+		this.strict = true;
+		const classScope = this._open("class", node, true);
+		this.labelsInScope = new Map();
+		const id = tree.field(0, Field.id, node);
+		if (id !== 0) {
+			const name = tree.name(id);
+			this._markExport(
+				this.types[node] === NodeType.ClassDeclaration
+					? this._defineVariable(outer, id, name, DECLARES_DEF_CLASS)
+					: this._defineVariable(classScope, id, name, DECLARES_CLASS),
+				1
+			);
+		}
+		this._visitChild(Field.superClass, node);
+		this._visitList(Field.body, tree.field(0, Field.body, node));
+		this.scope = outer;
+		this.labelsInScope = outerLabels;
+		this.strict = outerStrict;
+		this.stack.pop();
+	}
+
+	/**
+	 * @param {number} node a `var`, `let`, `const` or `using`
+	 * @returns {void}
+	 */
+	_visitDeclaration(node) {
+		const { stack, tree, functionDeclarators, classDeclarators } = this;
+		const text = tree.textOf(Part.kind, node);
+		const kind =
+			text === "var"
+				? DECLARES_VAR
+				: text === "let"
+					? DECLARES_LET
+					: text === "const"
+						? DECLARES_CONST
+						: DECLARES_USING;
+		stack.push(node);
+		const count = tree.fieldCount(Field.declarations, node);
+		for (let i = 0; i < count; i++) {
+			const declarator = tree.field(i, Field.declarations, node);
+			const id = tree.field(0, Field.id, declarator);
+			const init = this._child(Field.init, declarator);
+			if (
+				functionDeclarators !== null &&
+				kind !== DECLARES_USING &&
+				this.types[id] === NodeType.Identifier &&
+				init !== 0 &&
+				(this.types[init] === NodeType.FunctionExpression ||
+					this.types[init] === NodeType.ArrowFunctionExpression) &&
+				tree.field(0, Field.id, init) === 0
+			) {
+				functionDeclarators.push(id);
+			} else if (
+				classDeclarators !== null &&
+				kind !== DECLARES_USING &&
+				this.types[id] === NodeType.Identifier &&
+				init !== 0 &&
+				this.types[init] === NodeType.ClassExpression &&
+				tree.field(0, Field.id, init) === 0
+			) {
+				classDeclarators.push(id);
+			}
+			stack.push(declarator);
+			this._visitBinding(id, kind);
+			if (init !== 0) this._visit(init);
+			stack.pop();
+		}
+		stack.pop();
+	}
+
+	/**
+	 * A loop's children, its scope entered.
+	 * @param {number} node the loop
+	 * @returns {void}
+	 */
+	_visitLoop(node) {
+		switch (this.types[node]) {
+			case NodeType.ForStatement:
+				this._visitChild(Field.init, node);
+				this._visitChild(Field.test, node);
+				this._visitChild(Field.update, node);
+				break;
+			case NodeType.WhileStatement:
+				this._visitChild(Field.test, node);
+				break;
+			case NodeType.DoWhileStatement:
+				this._visitChild(Field.body, node);
+				this._visitChild(Field.test, node);
+				return;
+			default:
+				this._visitBinding(this._child(Field.left, node), 0);
+				this._visitChild(Field.right, node);
+		}
+		this._visitChild(Field.body, node);
+	}
+
+	/**
+	 * Reads one node as `MinifierScopeAnalyzer#_visitPrint` reads terser's.
+	 * @param {number} node node to visit
+	 * @returns {void}
+	 */
+	_visit(node) {
+		const { stack, tree } = this;
+		const type = this.types[node];
+		switch (type) {
+			case NodeType.Identifier: {
+				// A number too large for a double, which terser holds as an atom.
+				if (tree.type(node) !== NodeType.Identifier) return;
+				const parentType = this.types[stack[stack.length - 1]];
+				this._addReference(
+					node,
+					tree.name(node) === "eval" &&
+						(parentType === NodeType.CallExpression ||
+							parentType === NodeType.NewExpression)
+						? REFERENCE_CALLED
+						: 0
+				);
+				return;
+			}
+			case NodeType.MemberExpression: {
+				stack.push(node);
+				this._visitChild(Field.object, node);
+				const property = this._child(Field.property, node);
+				if (tree.flag(Flag.computed, node)) {
+					this._visit(property);
+				} else if (tree.type(property) === NodeType.PrivateIdentifier) {
+					this.namesPrivate = true;
+				}
+				stack.pop();
+				return;
+			}
+			case NodeType.CallExpression:
+			case NodeType.NewExpression:
+				// terser's walk reaches the arguments first.
+				stack.push(node);
+				this._visitList(Field.arguments, node);
+				this._visitChild(Field.callee, node);
+				stack.pop();
+				return;
+			case NodeType.Literal:
+			case NodeType.ThisExpression:
+				return;
+			case NodeType.ExpressionStatement: {
+				const directive = tree.textOf(Part.directive, node);
+				if (directive !== null) {
+					if (directive === "use strict") this.strict = true;
+					return;
+				}
+				stack.push(node);
+				this._visitChild(Field.expression, node);
+				stack.pop();
+				return;
+			}
+			case NodeType.BinaryExpression:
+			case NodeType.LogicalExpression:
+			case NodeType.AssignmentExpression:
+				stack.push(node);
+				this._visitChild(Field.left, node);
+				this._visitChild(Field.right, node);
+				stack.pop();
+				return;
+			case NodeType.BlockStatement: {
+				stack.push(node);
+				const outer = this._enterBlock("block", node);
+				this._visitList(Field.body, node);
+				this.scope = outer;
+				stack.pop();
+				return;
+			}
+			case NodeType.ReturnStatement:
+			case NodeType.UnaryExpression:
+			case NodeType.UpdateExpression:
+			case NodeType.ThrowStatement:
+			case NodeType.AwaitExpression:
+			case NodeType.SpreadElement:
+			case NodeType.YieldExpression:
+				stack.push(node);
+				this._visitChild(Field.argument, node);
+				stack.pop();
+				return;
+			case NodeType.VariableDeclaration:
+				this._visitDeclaration(node);
+				return;
+			case NodeType.FunctionDeclaration:
+			case NodeType.FunctionExpression:
+			case NodeType.ArrowFunctionExpression:
+				this._visitFunction(node);
+				return;
+			case NodeType.ClassDeclaration:
+			case NodeType.ClassExpression:
+				this._visitClass(node);
+				return;
+			case NodeType.ForStatement:
+			case NodeType.ForInStatement:
+			case NodeType.ForOfStatement:
+			case NodeType.WhileStatement:
+			case NodeType.DoWhileStatement: {
+				stack.push(node);
+				const outer = this._enterBlock(
+					type === NodeType.WhileStatement || type === NodeType.DoWhileStatement
+						? "block"
+						: "for",
+					node
+				);
+				this._visitLoop(node);
+				this.scope = outer;
+				stack.pop();
+				return;
+			}
+			case NodeType.SwitchStatement: {
+				stack.push(node);
+				const outer = this._enterBlock("switch", node);
+				// The switched expression belongs to the scope around the switch.
+				const block = this.scope;
+				this.scope = outer;
+				this._visitChild(Field.discriminant, node);
+				this.scope = block;
+				this._visitList(Field.cases, node);
+				this.scope = outer;
+				stack.pop();
+				return;
+			}
+			case NodeType.CatchClause: {
+				stack.push(node);
+				const outer = this._enterBlock("catch", node);
+				const catchScope = this.scope;
+				const param = tree.field(0, Field.param, node);
+				const ranged = this.parameterScopes && param !== 0;
+				if (ranged) {
+					catchScope.parameterStart = this.referenceNodes.length;
+					this.parameterRanges.push(catchScope);
+				}
+				if (param !== 0) this._visitBinding(param, DECLARES_CATCH);
+				if (ranged) catchScope.parameterEnd = this.referenceNodes.length;
+				this._visitList(Field.body, tree.field(0, Field.body, node));
+				this.scope = outer;
+				stack.pop();
+				return;
+			}
+			case NodeType.StaticBlock: {
+				const outer = this.scope;
+				const outerLabels = this.labelsInScope;
+				stack.push(node);
+				this._open("class-static-block", node, true);
+				this.labelsInScope = new Map();
+				this._visitList(Field.body, node);
+				this.scope = outer;
+				this.labelsInScope = outerLabels;
+				stack.pop();
+				return;
+			}
+			case NodeType.LabeledStatement: {
+				// The tree's parser refuses a label defined twice or undefined.
+				const labelName = tree.field(0, Field.label, node);
+				const name = tree.name(labelName);
+				const label = new MinifierLabel(name, this.currentLabel);
+				this.labels.push(label);
+				this.definitions[labelName] = label;
+				this.labelsInScope.set(name, label);
+				stack.push(node);
+				this.currentLabel = label;
+				this._visitChild(Field.body, node);
+				this.currentLabel = label.parent;
+				stack.pop();
+				this.labelsInScope.delete(name);
+				return;
+			}
+			case NodeType.BreakStatement:
+			case NodeType.ContinueStatement: {
+				const labelName = tree.field(0, Field.label, node);
+				if (labelName === 0) return;
+				this.definitions[labelName] = /** @type {MinifierLabel} */ (
+					this.labelsInScope.get(tree.name(labelName))
+				);
+				return;
+			}
+			case NodeType.WithStatement:
+				for (
+					let outer = /** @type {MinifierScope | null} */ (this.scope);
+					outer !== null;
+					outer = /** @type {MinifierScope | null} */ (outer.upper)
+				) {
+					outer.usesWith = true;
+				}
+				stack.push(node);
+				this._visitChild(Field.object, node);
+				this._visitChild(Field.body, node);
+				stack.pop();
+				return;
+			case NodeType.Property:
+			case NodeType.PropertyDefinition:
+				if (
+					tree.type(tree.field(0, Field.key, node)) ===
+					NodeType.PrivateIdentifier
+				) {
+					this.namesPrivate = true;
+				}
+				stack.push(node);
+				if (tree.flag(Flag.computed, node)) this._visitChild(Field.key, node);
+				this._visitChild(Field.value, node);
+				if (
+					this.types[node] === NodeType.Property &&
+					tree.textOf(Part.kind, node) === "init" &&
+					!tree.flag(Flag.method, node)
+				) {
+					this._spellProperty(node);
+				}
+				stack.pop();
+				return;
+			case NodeType.ObjectPattern:
+			case NodeType.ArrayPattern:
+			case NodeType.AssignmentPattern:
+			case NodeType.RestElement:
+				this._visitBinding(node, 0);
+				return;
+			case NodeType.TemplateLiteral:
+				// Its strings, between the expressions, read nothing.
+				stack.push(node);
+				this._visitList(Field.expressions, node);
+				stack.pop();
+				return;
+			case NodeType.ImportExpression:
+				stack.push(node);
+				this._visitChild(Field.source, node);
+				this._visitChild(Field.options, node);
+				stack.pop();
+				return;
+			case NodeType.MethodDefinition:
+				if (
+					tree.type(tree.field(0, Field.key, node)) ===
+					NodeType.PrivateIdentifier
+				) {
+					this.namesPrivate = true;
+				}
+				stack.push(node);
+				if (tree.flag(Flag.computed, node)) this._visitChild(Field.key, node);
+				this._visitChild(Field.value, node);
+				stack.pop();
+				return;
+			case NodeType.IfStatement:
+			case NodeType.ConditionalExpression:
+				stack.push(node);
+				this._visitChild(Field.test, node);
+				this._visitChild(Field.consequent, node);
+				this._visitChild(Field.alternate, node);
+				stack.pop();
+				return;
+			case NodeType.SwitchCase:
+				stack.push(node);
+				this._visitChild(Field.test, node);
+				this._visitList(Field.consequent, node);
+				stack.pop();
+				return;
+			case NodeType.ArrayExpression:
+				stack.push(node);
+				this._visitList(Field.elements, node);
+				stack.pop();
+				return;
+			case NodeType.ObjectExpression:
+				stack.push(node);
+				this._visitList(Field.properties, node);
+				stack.pop();
+				return;
+			case NodeType.SequenceExpression:
+				stack.push(node);
+				this._visitList(Field.expressions, node);
+				stack.pop();
+				return;
+			case NodeType.TaggedTemplateExpression:
+				stack.push(node);
+				this._visitChild(Field.tag, node);
+				this._visitChild(Field.quasi, node);
+				stack.pop();
+				return;
+			case NodeType.ChainExpression:
+				stack.push(node);
+				this._visitChild(Field.expression, node);
+				stack.pop();
+				return;
+			case NodeType.TryStatement:
+				stack.push(node);
+				this._visitChild(Field.block, node);
+				this._visitChild(Field.handler, node);
+				this._visitChild(Field.finalizer, node);
+				stack.pop();
+				return;
+			case NodeType.PrivateIdentifier:
+				this.namesPrivate = true;
+				return;
+			case NodeType.ImportDeclaration: {
+				this._checkModuleStatement(node, "Import");
+				stack.push(node);
+				const count = tree.fieldCount(Field.specifiers, node);
+				for (let i = 0; i < count; i++) {
+					const specifier = tree.field(i, Field.specifiers, node);
+					const local = tree.field(0, Field.local, specifier);
+					// terser holds a default import's name with no node around it.
+					if (this.types[specifier] === NodeType.ImportDefaultSpecifier) {
+						this._declare(local, DECLARES_IMPORT);
+						continue;
+					}
+					stack.push(specifier);
+					this._declare(local, DECLARES_IMPORT);
+					if (this.types[specifier] === NodeType.ImportSpecifier) {
+						this._spell(
+							local,
+							tree.field(0, Field.imported, specifier),
+							AS_SAVING
+						);
+					}
+					stack.pop();
+				}
+				stack.pop();
+				return;
+			}
+			case NodeType.ExportNamedDeclaration: {
+				this._checkModuleStatement(node, "Export");
+				stack.push(node);
+				this._visitChild(Field.declaration, node);
+				const flags =
+					tree.field(0, Field.source, node) !== 0
+						? REFERENCE_EXPORTED | REFERENCE_FROM_MODULE
+						: REFERENCE_EXPORTED;
+				const count = tree.fieldCount(Field.specifiers, node);
+				for (let i = 0; i < count; i++) {
+					const specifier = tree.field(i, Field.specifiers, node);
+					stack.push(specifier);
+					const local = tree.field(0, Field.local, specifier);
+					this._addReference(local, flags);
+					if ((flags & REFERENCE_FROM_MODULE) === 0) {
+						this._spell(
+							local,
+							tree.field(0, Field.exported, specifier),
+							AS_SAVING
+						);
+					}
+					stack.pop();
+				}
+				stack.pop();
+				return;
+			}
+			case NodeType.ExportDefaultDeclaration:
+				this._checkModuleStatement(node, "Export");
+				stack.push(node);
+				this._visitChild(Field.declaration, node);
+				stack.pop();
+				return;
+			case NodeType.ExportAllDeclaration:
+				// terser's `*` reads a global no name in the output depends on.
+				this._checkModuleStatement(node, "Export");
+				return;
+			case NodeType.Super:
+			case NodeType.EmptyStatement:
+			case NodeType.DebuggerStatement:
+			case NodeType.MetaProperty:
+				return;
+			default:
+				throw new Error(
+					`The minifier's scope analysis cannot read a node of type ${type}`
+				);
+		}
+	}
+
+	/**
+	 * Resolves each name read, finds `eval`, and encloses what a catch
+	 * parameter redefines.
+	 * @returns {void}
+	 */
+	_resolve() {
+		const { referenceNodes, referenceScopes, referenceFlags, globals, tree } =
+			this;
+		for (let i = 0; i < referenceNodes.length; i++) {
+			const node = referenceNodes[i];
+			const from = referenceScopes[i];
+			const flags = referenceFlags[i];
+			if (flags & REFERENCE_CATCH) {
+				const redefinition = /** @type {MinifierVariable | undefined} */ (
+					from.variableScope.getBinding(tree.name(node))
+				);
+				if (redefinition !== undefined) encloseVariable(from, redefinition);
+				continue;
+			}
+			const name = this._nameOf(node);
+			if (flags & REFERENCE_CALLED) {
+				for (
+					let outer = /** @type {MinifierScope | null} */ (from);
+					outer !== null && !outer.usesEval;
+					outer = /** @type {MinifierScope | null} */ (outer.upper)
+				) {
+					outer.usesEval = true;
+				}
+			}
+			let variable =
+				flags & REFERENCE_FROM_MODULE
+					? undefined
+					: findMinifierVariable(from, name, i);
+			if (variable === undefined) {
+				variable = globals.get(name);
+				if (variable === undefined) {
+					variable = new MinifierVariable(name, this.toplevel, DECLARES_GLOBAL);
+					variable.undeclared = true;
+					variable.global = true;
+					globals.set(name, variable);
+				}
+				if (flags & REFERENCE_EXPORTED) variable.export = EXPORT_KEEP_NAME;
+			}
+			if (tree.type(node) === NodeType.Identifier) {
+				this.definitions[node] = variable;
+				this._referenceVariable(from, variable);
+			} else {
+				// A re-exported string reads a global, which keeps no references.
+				encloseVariable(from, variable);
+			}
+		}
+		const { parameterRanges } = this;
+		for (let i = 0; i < parameterRanges.length; i++) {
+			parameterRanges[i].parameterStart = -1;
+			parameterRanges[i].parameterEnd = -1;
+		}
+	}
+
+	/**
+	 * @param {number[]} identifiers names
+	 * @returns {PrintIdentifier[]} each as the mangler reads it: its name and its definition
+	 */
+	_asNames(identifiers) {
+		return identifiers.map(
+			(identifier) =>
+				/** @type {PrintIdentifier} */ (
+					/** @type {unknown} */ ({
+						name: this.tree.name(identifier),
+						definition: this.definitions[identifier]
+					})
+				)
+		);
+	}
+}
+
+/**
+ * Analyses a `SyntaxTree` as `analyzeMinifierScope` does terser's tree of
+ * the same source; neither `ie8` nor `safari10` may be on.
+ * @param {SyntaxTree} tree the tree
+ * @param {number} program its program
+ * @param {Uint8Array} types each node's type, as terser's tree types it
+ * @param {MinifierScopeOptions} options the mangle options
+ * @param {(node: number, message: string) => never} raise throws the parse error a misplaced import or export is
+ * @returns {MinifierTreeScopeAnalysis} the scopes, and each name's definition
+ */
+const analyzeMinifierTree = (tree, program, types, options, raise) => {
+	if (NodeType === undefined) {
+		({ NodeType, Field, Flag, Part } = require("./data"));
+	}
+	const analyzer = new MinifierTreeScopeAnalyzer(
+		tree,
+		program,
+		types,
+		options,
+		raise
+	);
+	analyzer.stack.push(program);
+	analyzer._visitList(Field.body, program);
+	analyzer.stack.pop();
+	analyzer._resolve();
+	const { functionDeclarators, classDeclarators } = analyzer;
+	return {
+		toplevel: analyzer.toplevel,
+		labels: analyzer.labels,
+		globals: analyzer.globals,
+		blockDefunScopes: analyzer.blockDefunScopes,
+		functionDeclarators:
+			functionDeclarators === null
+				? null
+				: analyzer._asNames(functionDeclarators),
+		classDeclarators:
+			classDeclarators === null ? null : analyzer._asNames(classDeclarators),
+		catchParameters: analyzer._asNames(analyzer.catchParameters),
+		namesPrivate: analyzer.namesPrivate,
+		spelledNames: analyzer._spelledNames(),
+		definitions: analyzer.definitions
+	};
+};
+
+// The declarations whose name a block keeps: a read of any other name from a
+// block is the function's, as terser re-points it.
+const BLOCK_DECLARATIONS =
+	(1 << DECLARES_LET) |
+	(1 << DECLARES_CONST) |
+	(1 << DECLARES_USING) |
+	(1 << DECLARES_CATCH) |
+	(1 << DECLARES_DEF_CLASS) |
+	(1 << DECLARES_IMPORT);
+
+// The declarations naming a function, which terser's `def_function` defines.
+const FUNCTION_DECLARATIONS =
+	(1 << DECLARES_LAMBDA) | (1 << DECLARES_DEFUN) | (1 << DECLARES_DEF_CLASS);
+
+/**
+ * What the compressor's analysis asks of its tree's nodes, which only the
+ * tree's kinds answer.
+ * @typedef {object} CompressorDialect
+ * @property {(node: CompressorNode) => boolean} isSymbol whether a node is one of terser's symbols, which records its scope
+ * @property {(node: CompressorNode) => boolean} isFunction whether a node is a function expression, not a method
+ * @property {(node: CompressorNode) => boolean} isDefun whether a node is a function declaration
+ * @property {(node: CompressorNode) => boolean} isObjectKeyValue whether a property is a plain key and value, its key a name only where computed
+ * @property {(node: CompressorNode) => boolean} isPrivateField whether a class field is a private one, its key no symbol
+ * @property {(lambda: CompressorNode) => CompressorNode} argumentsSymbol the symbol a function's own `arguments` is declared by
+ */
+
+/**
+ * The compressor's analysis: the minifier's, recording what terser's
+ * `figure_out_scope` gives the compressor besides. Each scope is a
+ * `CompressorScope` its node holds, each definition a `CompressorVariable`
+ * with its declaring symbols, its value and its reads, and each symbol its
+ * scope; a label is its own definition, its `break`s and `continue`s its
+ * references.
+ */
+class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
+	/**
+	 * @param {CompressorNode} root the program, or a function or class analysed again
+	 * @param {MinifierScopeOptions} options the options
+	 * @param {(node: PrintNode, message: string, tables?: TokenTables) => never} raise throws the parse error a misplaced declaration is
+	 * @param {CompressorDialect} dialect what the tree's kinds answer
+	 * @param {CompressorScopeShape} parentScope the scope the root sits in, the program's own for the program
+	 * @param {CompressorScopeShape} toplevel the program's scope
+	 */
+	constructor(root, options, raise, dialect, parentScope, toplevel) {
+		super(
+			/** @type {PrintProgram} */ (/** @type {unknown} */ (root)),
+			{
+				ie8: options.ie8,
+				safari10: options.safari10,
+				module: options.module,
+				parameterScopes: options.parameterScopes
+			},
+			raise,
+			undefined
+		);
+		/** @type {CompressorDialect} */
+		this.dialect = dialect;
+		this.toplevel = /** @type {MinifierScope} */ (
+			/** @type {unknown} */ (toplevel)
+		);
+		this.tokenTables =
+			/** @type {PrintProgram} */ (/** @type {unknown} */ (toplevel.node))
+				.tokenTables || undefined;
+		this.scope = /** @type {MinifierScope} */ (
+			/** @type {unknown} */ (parentScope)
+		);
+		// The program's node holds its globals, as terser's did.
+		this.globals = /** @type {Map<string, MinifierVariable>} */ (
+			/** @type {CompressorNode} */ (/** @type {unknown} */ (toplevel.node))
+				.globals
+		);
+	}
+
+	/**
+	 * @param {ScopeType} type what opens it
+	 * @param {PrintNode} node the node opening it
+	 * @param {boolean} isVarScope whether `var` hoists to here
+	 * @returns {MinifierScope} the scope, now current
+	 */
+	_open(type, node, isVarScope) {
+		const opener = /** @type {CompressorNode} */ (
+			/** @type {unknown} */ (node)
+		);
+		const scope = createCompressorScope(
+			type,
+			opener,
+			/** @type {CompressorScopeShape | null} */ (
+				/** @type {unknown} */ (this.scope)
+			),
+			isVarScope
+		);
+		// eslint-disable-next-line camelcase -- terser's name, which the compressor reads
+		opener.block_scope = scope;
+		this.scope = /** @type {MinifierScope} */ (/** @type {unknown} */ (scope));
+		return this.scope;
+	}
+
+	/**
+	 * terser's `def_variable`, the scope's binding of the name already looked up.
+	 * @param {MinifierScope} target the scope declaring it
+	 * @param {MinifierVariable | undefined} variable what the scope binds the name to, if anything
+	 * @param {PrintIdentifier | null} identifier the name declaring it, if written
+	 * @param {string} name the name
+	 * @param {number} kind how it is declared
+	 * @returns {MinifierVariable} its definition, made or joined
+	 */
+	_addDeclaration(target, variable, identifier, name, kind) {
+		const scope = /** @type {CompressorScopeShape} */ (
+			/** @type {unknown} */ (target)
+		);
+		const opener = /** @type {CompressorNode} */ (
+			/** @type {unknown} */ (/** @type {MinifierScope} */ (this.scope).node)
+		);
+		/** @type {CompressorNode | null | undefined} */
+		let init;
+		let symbol;
+		if (identifier === null) {
+			symbol = this.dialect.argumentsSymbol(opener);
+		} else {
+			symbol = /** @type {CompressorNode} */ (
+				/** @type {unknown} */ (identifier)
+			);
+			if ((1 << kind) & (FUNCTION_DECLARATIONS | (1 << DECLARES_CLASS))) {
+				// A function's or class's name, its scope where it is declared.
+				symbol.scope = /** @type {CompressorNode} */ (
+					/** @type {unknown} */ (scope)
+				);
+				// A function expression named `arguments` is not its own value.
+				init =
+					kind === DECLARES_LAMBDA && name === "arguments" ? undefined : opener;
+			} else if (kind !== DECLARES_FUNARG && kind !== DECLARES_IMPORT) {
+				init = null;
+			}
+		}
+		let definition = /** @type {CompressorDefinition | undefined} */ (
+			/** @type {unknown} */ (variable)
+		);
+		if (definition !== undefined) {
+			definition.declarations |= 1 << kind;
+			definition.identifiers.push(symbol);
+			if (
+				definition.init &&
+				(definition.scope !== /** @type {unknown} */ (symbol.scope) ||
+					this.dialect.isFunction(definition.init))
+			) {
+				definition.init = init;
+			}
+		} else {
+			definition = createCompressorDefinition(name, scope, kind, symbol, init);
+			definition.global = scope.upper === null;
+			scope.bind(definition);
+		}
+		if (
+			(1 << kind) & FUNCTION_DECLARATIONS &&
+			(!definition.init || this.dialect.isDefun(definition.init))
+		) {
+			definition.init = init;
+		}
+		symbol.definition = definition;
+		return /** @type {MinifierVariable} */ (
+			/** @type {unknown} */ (definition)
+		);
+	}
+
+	/**
+	 * terser's `reference`.
+	 * @param {PrintIdentifier} identifier the name read
+	 * @param {MinifierScope} from the scope reading it
+	 * @param {MinifierVariable} variable what it reads
+	 * @returns {void}
+	 */
+	_referenceVariable(identifier, from, variable) {
+		/** @type {CompressorDefinition} */ (
+			/** @type {unknown} */ (variable)
+		).references.push(
+			/** @type {CompressorNode} */ (/** @type {unknown} */ (identifier))
+		);
+		encloseVariable(from, variable);
+	}
+
+	/**
+	 * A `var`, parameter, `let`, `const`, `using`, catch parameter or import.
+	 * @param {PrintIdentifier} identifier the name declared
+	 * @param {number} kind how, as a `DECLARES_*` code
+	 * @returns {void}
+	 */
+	_declare(identifier, kind) {
+		/** @type {CompressorNode} */ (/** @type {unknown} */ (identifier)).scope =
+			/** @type {CompressorNode} */ (/** @type {unknown} */ (this.scope));
+		super._declare(identifier, kind);
+	}
+
+	/**
+	 * @param {PrintIdentifier | PrintLiteral} node a name read, or a re-exported string
+	 * @param {number} flags what else is known of it, as `REFERENCE_*` bits
+	 * @returns {void}
+	 */
+	_addReference(node, flags) {
+		// The name holds the scope it is read in, as its `scope`.
+		this.referenceNodes.push(node);
+		this.referenceFlags.push(flags);
+	}
+
+	/**
+	 * Records the scope of a symbol the walk reaches but the minifier's does not
+	 * read: a member's name, a label, or a name an import or export maps.
+	 * @param {PrintNode | CompressorNode | null | undefined} node a node, if any
+	 * @returns {void}
+	 */
+	_recordScope(node) {
+		if (node === null || node === undefined) return;
+		const symbol = /** @type {CompressorNode} */ (
+			/** @type {unknown} */ (node)
+		);
+		if (this.dialect.isSymbol(symbol)) {
+			symbol.scope = /** @type {CompressorNode} */ (
+				/** @type {unknown} */ (this.scope)
+			);
+		}
+	}
+
+	/**
+	 * Reads what is scoped as webpack does with the shared walk, pushed as
+	 * terser's walk pushes it, and the rest as terser's analysis does.
+	 * @param {PrintNode} current node to visit
+	 * @returns {void}
+	 */
+	_visitPrint(current) {
+		const node = /** @type {CompressorNode} */ (
+			/** @type {unknown} */ (current)
+		);
+		switch (current.type) {
+			case "Identifier":
+			case "ThisExpression":
+			case "Super":
+			case "PrivateIdentifier":
+			case "Literal":
+				this._recordScope(current);
+				break;
+			case "MethodDefinition":
+				if (!current.computed) this._recordScope(current.key);
+				break;
+			case "Property":
+				if (
+					!current.computed &&
+					!this.dialect.isObjectKeyValue(
+						/** @type {CompressorNode} */ (/** @type {unknown} */ (current))
+					)
+				) {
+					this._recordScope(current.key);
+				}
+				break;
+			case "PropertyDefinition":
+				if (
+					!current.computed &&
+					!this.dialect.isPrivateField(
+						/** @type {CompressorNode} */ (/** @type {unknown} */ (current))
+					)
+				) {
+					this._recordScope(current.key);
+				}
+				break;
+			case "LabeledStatement":
+				this._visitLabeled(node);
+				return;
+			case "BreakStatement":
+			case "ContinueStatement":
+				this._visitLoopControl(node);
+				return;
+			case "ImportDeclaration":
+				this._visitNameMappings(node.imported_names);
+				break;
+			case "ExportNamedDeclaration":
+				this._visitNameMappings(node.exported_names);
+				break;
+			case "ExportAllDeclaration":
+				this._visitExportAll(node);
+				return;
+		}
+		super._visitPrint(current);
+	}
+
+	/**
+	 * @param {CompressorNode[] | null | undefined} mappings an import's or export's names
+	 * @returns {void}
+	 */
+	_visitNameMappings(mappings) {
+		if (!mappings) return;
+		for (let i = 0; i < mappings.length; i++) {
+			const mapping = mappings[i];
+			this._recordScope(mapping.imported);
+			this._recordScope(mapping.exported);
+			this._recordScope(mapping.local);
+		}
+	}
+
+	/**
+	 * An `export *`, whose names read terser's `*` global.
+	 * @param {CompressorNode} node the export
+	 * @returns {void}
+	 */
+	_visitExportAll(node) {
+		const exported = /** @type {PrintNode} */ (/** @type {unknown} */ (node));
+		this._checkModuleStatement(exported, "Export");
+		/** @type {CompressorNode[]} */
+		const names = node.exported_names;
+		this._visitNameMappings(names);
+		const stack = this.stack;
+		stack.push(exported);
+		for (let i = 0; i < names.length; i++) {
+			const mapping = names[i];
+			stack.push(/** @type {PrintNode} */ (/** @type {unknown} */ (mapping)));
+			this._addReference(
+				/** @type {PrintIdentifier} */ (mapping.local),
+				REFERENCE_EXPORTED | REFERENCE_FROM_MODULE
+			);
+			stack.pop();
+		}
+		stack.pop();
+	}
+
+	/**
+	 * A labeled statement, its label its own definition.
+	 * @param {CompressorNode} node the statement
+	 * @returns {void}
+	 */
+	_visitLabeled(node) {
+		const { label } = node;
+		const { name } = label;
+		const labels = /** @type {Map<string, CompressorNode>} */ (
+			/** @type {unknown} */ (this.labelsInScope)
+		);
+		if (labels.has(name)) throw new Error(`Label ${name} defined twice`);
+		this._recordScope(label);
+		// A label's definition is the label itself.
+		label.definition = /** @type {CompressorDefinition} */ (
+			/** @type {unknown} */ (label)
+		);
+		label.references = [];
+		labels.set(name, label);
+		this.stack.push(/** @type {PrintNode} */ (/** @type {unknown} */ (node)));
+		this._visitPrint(node.body);
+		this.stack.pop();
+		labels.delete(name);
+	}
+
+	/**
+	 * A `break` or `continue`, one of its label's references.
+	 * @param {CompressorNode} node the statement
+	 * @returns {void}
+	 */
+	_visitLoopControl(node) {
+		const name = /** @type {CompressorNode | null} */ (node.label);
+		if (!name) return;
+		this._recordScope(name);
+		const label = /** @type {Map<string, CompressorNode>} */ (
+			/** @type {unknown} */ (this.labelsInScope)
+		).get(name.name);
+		if (label === undefined) {
+			const start = /** @type {Token} */ (this.tokenOf(name.startToken));
+			throw new Error(
+				`Undefined label ${name.name} [${start.line},${start.col}]`
+			);
+		}
+		name.definition = /** @type {CompressorDefinition} */ (
+			/** @type {unknown} */ (label)
+		);
+		label.references.push(node);
+	}
+
+	/**
+	 * Resolves each name read as terser's compressor reads it: the definition's
+	 * reads, a function's own `arguments` read, and a read from a block of a
+	 * name the block does not keep moved to the function's scope.
+	 * @returns {void}
+	 */
+	_resolveCompressor() {
+		const { referenceNodes, referenceFlags } = this;
+		const globals = /** @type {Map<string, CompressorDefinition>} */ (
+			/** @type {unknown} */ (this.globals)
+		);
+		const toplevel = /** @type {CompressorScopeShape} */ (
+			/** @type {unknown} */ (this.toplevel)
+		);
+		for (let i = 0; i < referenceNodes.length; i++) {
+			const node = /** @type {CompressorNode} */ (
+				/** @type {unknown} */ (referenceNodes[i])
+			);
+			const from = /** @type {MinifierScope} */ (
+				/** @type {unknown} */ (node.scope)
+			);
+			const flags = referenceFlags[i];
+			const { name } = node;
+			if (flags & REFERENCE_CATCH) {
+				const redefinition = /** @type {MinifierVariable | undefined} */ (
+					from.variableScope.getBinding(name)
+				);
+				if (redefinition !== undefined) encloseVariable(from, redefinition);
+				continue;
+			}
+			if (flags & REFERENCE_CALLED) {
+				for (
+					let outer = /** @type {MinifierScope | null} */ (from);
+					outer !== null && !outer.usesEval;
+					outer = /** @type {MinifierScope | null} */ (outer.upper)
+				) {
+					outer.usesEval = true;
+				}
+			}
+			let definition = /** @type {CompressorDefinition | undefined} */ (
+				/** @type {unknown} */ (
+					flags & REFERENCE_FROM_MODULE
+						? undefined
+						: findMinifierVariable(from, name, i)
+				)
+			);
+			if (definition === undefined) {
+				definition = globals.get(name);
+				if (definition === undefined) {
+					definition = createCompressorDefinition(
+						name,
+						toplevel,
+						DECLARES_GLOBAL,
+						node,
+						undefined
+					);
+					definition.undeclared = true;
+					definition.global = true;
+					globals.set(name, definition);
+				}
+				if (flags & REFERENCE_EXPORTED) definition.export = EXPORT_KEEP_NAME;
+			} else if (name === "arguments" && definition.scope.type === "function") {
+				definition.scope.getDefunScope().usesArguments = true;
+			}
+			node.definition = definition;
+			definition.references.push(node);
+			encloseVariable(
+				from,
+				/** @type {MinifierVariable} */ (/** @type {unknown} */ (definition))
+			);
+			if (
+				from.variableScope !== from &&
+				((1 << definition.kind) & BLOCK_DECLARATIONS) === 0
+			) {
+				node.scope = /** @type {CompressorNode} */ (
+					/** @type {unknown} */ (from.variableScope)
+				);
+			}
+		}
+
+		this._clearParameterRanges();
+
+		// Passes 3 and 4: work around old engines' catch and loop scopes.
+		const { catchNames, catchScopes } = this;
+		for (let i = 0; i < catchNames.length; i++) {
+			const symbol = /** @type {CompressorNode} */ (
+				/** @type {unknown} */ (catchNames[i])
+			);
+			const { name } = symbol;
+			const { references } = symbol.definition;
+			const defunScope = /** @type {CompressorScopeShape} */ (
+				/** @type {unknown} */ (catchScopes[i].variableScope)
+			);
+			let definition = defunScope.findVariable(name) || globals.get(name);
+			if (definition === undefined) {
+				definition = createCompressorDefinition(
+					name,
+					defunScope,
+					DECLARES_CATCH,
+					symbol,
+					undefined
+				);
+				definition.global = defunScope.upper === null;
+				defunScope.bind(definition);
+			}
+			// As terser's `forEach`: referencing appends to the list it reads.
+			const { length } = references;
+			for (let j = 0; j < length; j++) {
+				const read = references[j];
+				read.definition = definition;
+				read.scope.addReference(read);
+			}
+			symbol.definition = definition;
+			symbol.scope.addReference(symbol);
+		}
+		const { forScopes } = this;
+		for (let i = 0; i < forScopes.length; i++) {
+			const forScope = forScopes[i];
+			const variables = /** @type {MinifierScope} */ (forScope.upper).variables;
+			for (let j = 0; j < variables.length; j++) {
+				encloseUnique(forScope, /** @type {MinifierVariable} */ (variables[j]));
+			}
+		}
+	}
+}
+
+/**
+ * Analyses the compressor's tree, or a function or class of it again, with
+ * terser's scoping, recording what the compressor reads: see
+ * `CompressorScopeAnalyzer`.
+ * @param {CompressorNode} root the program, or a function or class in it
+ * @param {MinifierScopeOptions} options the options
+ * @param {(node: PrintNode, message: string, tables?: TokenTables) => never} raise throws the parse error a misplaced declaration is
+ * @param {CompressorDialect} dialect what the tree's kinds answer
+ * @param {CompressorScopeShape | null} parentScope the scope the root sits in, unless it is the program
+ * @param {CompressorNode} program the program
+ * @returns {void}
+ */
+const analyzeCompressorScope = (
+	root,
+	options,
+	raise,
+	dialect,
+	parentScope,
+	program
+) => {
+	const isProgram = root === program;
+	let toplevel;
+	if (isProgram) {
+		toplevel = createCompressorScope("global", root, null, true);
+		root.globals = new Map();
+		// eslint-disable-next-line camelcase -- terser's name, which the compressor reads
+		root.block_scope = toplevel;
+	} else {
+		toplevel = program.block_scope;
+	}
+	const analyzer = new CompressorScopeAnalyzer(
+		root,
+		options,
+		raise,
+		dialect,
+		isProgram ? toplevel : /** @type {CompressorScopeShape} */ (parentScope),
+		toplevel
+	);
+	if (isProgram) {
+		analyzer.stack.push(
+			/** @type {PrintNode} */ (/** @type {unknown} */ (root))
+		);
+		analyzer._visitList(
+			/** @type {PrintProgram} */ (/** @type {unknown} */ (root)).body
+		);
+	} else {
+		// What a declaration's `export` is read off is not there.
+		analyzer.stack.push(
+			/** @type {PrintNode} */ (
+				/** @type {unknown} */ (
+					/** @type {CompressorScopeShape} */ (parentScope).node
+				)
+			)
+		);
+		analyzer._visitPrint(
+			/** @type {PrintNode} */ (/** @type {unknown} */ (root))
+		);
+	}
+	analyzer.stack.pop();
+	analyzer._resolveCompressor();
 };
 
 analyzeScope.Reference = Reference;
 analyzeScope.Scope = Scope;
 analyzeScope.Variable = Variable;
+analyzeScope.MinifierLabel = MinifierLabel;
+analyzeScope.MinifierScope = MinifierScope;
+analyzeScope.MinifierVariable = MinifierVariable;
+analyzeScope.isMinifierVariable = isMinifierVariable;
+analyzeScope.CompressorScope = CompressorScope;
+analyzeScope.CompressorVariable = CompressorVariable;
+analyzeScope.createCompressorDefinition = createCompressorDefinition;
+analyzeScope.createCompressorScope = createCompressorScope;
+analyzeScope.analyzeMinifierScope = analyzeMinifierScope;
+analyzeScope.analyzeMinifierTree = analyzeMinifierTree;
+analyzeScope.analyzeCompressorScope = analyzeCompressorScope;
+analyzeScope.encloseUnique = encloseUnique;
+analyzeScope.DECLARES_VAR = DECLARES_VAR;
+analyzeScope.DECLARES_FUNARG = DECLARES_FUNARG;
+analyzeScope.DECLARES_LET = DECLARES_LET;
+analyzeScope.DECLARES_CONST = DECLARES_CONST;
+analyzeScope.DECLARES_USING = DECLARES_USING;
+analyzeScope.DECLARES_CATCH = DECLARES_CATCH;
+analyzeScope.DECLARES_IMPORT = DECLARES_IMPORT;
+analyzeScope.DECLARES_DEFUN = DECLARES_DEFUN;
+analyzeScope.DECLARES_LAMBDA = DECLARES_LAMBDA;
+analyzeScope.DECLARES_CLASS = DECLARES_CLASS;
+analyzeScope.DECLARES_DEF_CLASS = DECLARES_DEF_CLASS;
+analyzeScope.DECLARES_GLOBAL = DECLARES_GLOBAL;
+analyzeScope.EXPORT_KEEP_NAME = EXPORT_KEEP_NAME;
+analyzeScope.EXPORT_WANT_MANGLE = EXPORT_WANT_MANGLE;
 
 module.exports = analyzeScope;