webpack 5.112.0 → 5.112.1

package/lib/javascript/ScopeAnalyzer.js

@@ -389,7 +389,7 @@ class ScopeAnalyzer {
 	 */
 	constructor(recordEveryReference) {
 		/** @type {Scope} the scope the walker is currently inside */
-		this.scope = /** @type {Scope} */ (/** @type {unknown} */ (null));
+		this.scope = /** @type {Scope} */ (/** @type {Scope | null} */ (null));
 		/** @type {Identifier[]} identifiers awaiting resolution */
 		this.pendingIdentifiers = [];
 		/** @type {Scope[]} the scope each pending identifier was seen in */
@@ -455,9 +455,9 @@ class ScopeAnalyzer {
 			addBinding(scope, variable);
 		}
 		if (variable.identifiers === NO_IDENTIFIERS) {
-			variable.identifiers = [/** @type {Identifier} */ (node)];
+			variable.identifiers = [node];
 		} else {
-			variable.identifiers.push(/** @type {Identifier} */ (node));
+			variable.identifiers.push(node);
 		}
 	}
 
@@ -722,8 +722,8 @@ class ScopeAnalyzer {
 			if (key === "key" && "computed" in node && node.computed === false) {
 				continue;
 			}
-			const child = /** @type {Record<string, unknown>} */ (
-				/** @type {unknown} */ (node)
+			const child = /** @type {NodeChildren} */ (
+				/** @type {Node | NodeChildren} */ (node)
 			)[key];
 			if (child === null || typeof child !== "object") continue;
 			if (Array.isArray(child)) {
@@ -732,8 +732,8 @@ class ScopeAnalyzer {
 						this._visit(item);
 					}
 				}
-			} else if (/** @type {Node} */ (child).type) {
-				this._visit(/** @type {Node} */ (child));
+			} else if (child.type) {
+				this._visit(child);
 			}
 		}
 	}
@@ -1019,7 +1019,7 @@ class ScopeAnalyzer {
 				}
 				for (let i = 0; i < keys.length; i++) {
 					const child = /** @type {NodeChildren} */ (
-						/** @type {unknown} */ (node)
+						/** @type {Node | NodeChildren} */ (node)
 					)[keys[i]];
 					if (child === null || child === undefined) continue;
 					if (Array.isArray(child)) {
@@ -1139,7 +1139,7 @@ const analyzeScope = (ast, recordEveryReference = false) => {
  * @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 {import("./syntax-printer").NodeToken} Token
  * @typedef {NonNullable<PrintProgram["tokenTables"]>} TokenTables
  * @typedef {import("./syntax-printer").Node} CompressorNode
  * @typedef {import("./syntax-printer").Scope} CompressorScopeShape
@@ -1367,7 +1367,7 @@ class MinifierVariable extends Variable {
 
 /**
  * Whether a definition is a variable rather than a label or a compressor's own definition.
- * @param {unknown} value a definition
+ * @param {MinifierVariable | MinifierLabel | CompressorDefinition | import("./syntax-printer").NamedDefinition | null | undefined} value a definition
  * @returns {value is MinifierVariable} true when the value is a variable
  */
 const isMinifierVariable = (value) => value instanceof MinifierVariable;
@@ -1408,11 +1408,15 @@ class CompressorScope extends MinifierScope {
 		// reads `childScopes`, and its tree moves, copies and drops scopes.
 		super(
 			type,
-			/** @type {PrintNode} */ (/** @type {unknown} */ (node)),
+			/** @type {PrintNode} */ (
+				/** @type {PrintNode | CompressorNode} */ (node)
+			),
 			null,
 			true
 		);
-		this.upper = /** @type {Scope | null} */ (/** @type {unknown} */ (upper));
+		this.upper = /** @type {Scope | null} */ (
+			/** @type {Scope | CompressorScopeShape | null} */ (upper)
+		);
 		if (!isVarScope) {
 			this.variableScope = /** @type {Scope} */ (this.upper).variableScope;
 		}
@@ -1437,7 +1441,7 @@ class CompressorScope extends MinifierScope {
 			this.type,
 			node,
 			/** @type {CompressorScopeShape | null} */ (
-				/** @type {unknown} */ (this.upper)
+				/** @type {CompressorScopeShape | Scope | null} */ (this.upper)
 			),
 			this.variableScope === this
 		);
@@ -1448,7 +1452,7 @@ class CompressorScope extends MinifierScope {
 		shared.usesWith = this.usesWith;
 		shared.usesArguments = this.usesArguments;
 		return /** @type {CompressorScopeShape} */ (
-			/** @type {unknown} */ (shared)
+			/** @type {CompressorScopeShape | CompressorScope} */ (shared)
 		);
 	}
 
@@ -1484,7 +1488,9 @@ class CompressorScope extends MinifierScope {
 	bind(variable) {
 		addBinding(
 			this,
-			/** @type {Variable} */ (/** @type {unknown} */ (variable))
+			/** @type {Variable} */ (
+				/** @type {Variable | CompressorDefinition} */ (variable)
+			)
 		);
 	}
 
@@ -1496,23 +1502,26 @@ class CompressorScope extends MinifierScope {
 	 * @returns {CompressorDefinition} its definition, made or joined
 	 */
 	defineVariable(symbol, init, isFunction) {
-		const name = /** @type {string} */ (symbol.name);
+		const name = symbol.name;
 		let variable = /** @type {CompressorDefinition | undefined} */ (
-			/** @type {unknown} */ (this.getBinding(name))
+			/** @type {CompressorDefinition | Variable | undefined} */ (
+				this.getBinding(name)
+			)
 		);
 		if (variable !== undefined) {
 			variable.identifiers.push(symbol);
 			if (
 				variable.init &&
-				(variable.scope !== /** @type {unknown} */ (symbol.scope) ||
-					isFunction(variable.init))
+				(variable.scope !== symbol.scope || isFunction(variable.init))
 			) {
 				variable.init = init;
 			}
 		} else {
 			variable = createCompressorDefinition(
 				name,
-				/** @type {CompressorScopeShape} */ (/** @type {unknown} */ (this)),
+				/** @type {CompressorScopeShape} */ (
+					/** @type {CompressorScopeShape | CompressorScope} */ (this)
+				),
 				0,
 				symbol,
 				init
@@ -1533,7 +1542,7 @@ class CompressorScope extends MinifierScope {
 	 */
 	adopt(child, readsArguments) {
 		const self = /** @type {CompressorScopeShape} */ (
-			/** @type {unknown} */ (this)
+			/** @type {CompressorScopeShape | CompressorScope} */ (this)
 		);
 		if (child.upper === self) return;
 		child.upper = self;
@@ -1561,12 +1570,14 @@ class CompressorScope extends MinifierScope {
 		const toEnclose = [];
 		for (const ancestor of ancestry) {
 			const scope = /** @type {MinifierScope} */ (
-				/** @type {unknown} */ (ancestor)
+				/** @type {MinifierScope | CompressorScopeShape} */ (ancestor)
 			);
 			for (const definition of toEnclose) {
 				encloseUnique(
 					scope,
-					/** @type {MinifierVariable} */ (/** @type {unknown} */ (definition))
+					/** @type {MinifierVariable} */ (
+						/** @type {MinifierVariable | CompressorDefinition} */ (definition)
+					)
 				);
 			}
 			const { variables } = ancestor;
@@ -1589,7 +1600,9 @@ class CompressorScope extends MinifierScope {
 					if (!toEnclose.includes(only)) toEnclose.push(only);
 					encloseUnique(
 						scope,
-						/** @type {MinifierVariable} */ (/** @type {unknown} */ (only))
+						/** @type {MinifierVariable} */ (
+							/** @type {MinifierVariable | CompressorDefinition} */ (only)
+						)
 					);
 					continue;
 				}
@@ -1601,7 +1614,9 @@ class CompressorScope extends MinifierScope {
 					encloseUnique(
 						scope,
 						/** @type {MinifierVariable} */ (
-							/** @type {unknown} */ (definition)
+							/** @type {MinifierVariable | CompressorDefinition} */ (
+								definition
+							)
 						)
 					);
 					if (--left === 0) break;
@@ -1620,7 +1635,9 @@ class CompressorScope extends MinifierScope {
 		variable.references.push(symbol);
 		encloseVariable(
 			this,
-			/** @type {MinifierVariable} */ (/** @type {unknown} */ (variable))
+			/** @type {MinifierVariable} */ (
+				/** @type {MinifierVariable | CompressorDefinition} */ (variable)
+			)
 		);
 	}
 }
@@ -1642,11 +1659,15 @@ class CompressorVariable extends MinifierVariable {
 	constructor(name, scope, kind, orig, init) {
 		super(
 			name,
-			/** @type {MinifierScope} */ (/** @type {unknown} */ (scope)),
+			/** @type {MinifierScope} */ (
+				/** @type {MinifierScope | CompressorScopeShape | null} */ (scope)
+			),
 			kind
 		);
 		this.identifiers = [
-			/** @type {Identifier} */ (/** @type {unknown} */ (orig))
+			/** @type {Identifier} */ (
+				/** @type {Identifier | CompressorNode | { name: string }} */ (orig)
+			)
 		];
 		/** @type {CompressorNode | null | undefined} what it is initialized to */
 		this.init = init;
@@ -1682,6 +1703,10 @@ class CompressorVariable extends MinifierVariable {
 		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;
+		/** @type {boolean} whether `reduce_vars` met a read of it before any value was set */
+		this.readUnset = false;
+		/** @type {boolean} whether `reduce_vars` met a declaration of it giving a value */
+		this.declaredWithValue = false;
 	}
 }
 
@@ -1696,7 +1721,7 @@ class CompressorVariable extends MinifierVariable {
  */
 const createCompressorDefinition = (name, scope, kind, orig, init) =>
 	/** @type {CompressorDefinition} */ (
-		/** @type {unknown} */ (
+		/** @type {CompressorDefinition | CompressorVariable} */ (
 			new CompressorVariable(name, scope, kind, orig, init)
 		)
 	);
@@ -1711,7 +1736,9 @@ const createCompressorDefinition = (name, scope, kind, orig, init) =>
  */
 const createCompressorScope = (type, node, upper, isVarScope) =>
 	/** @type {CompressorScopeShape} */ (
-		/** @type {unknown} */ (new CompressorScope(type, node, upper, isVarScope))
+		/** @type {CompressorScopeShape | CompressorScope} */ (
+			new CompressorScope(type, node, upper, isVarScope)
+		)
 	);
 
 /**
@@ -1787,12 +1814,13 @@ const bindsName = (node, name) => {
 };
 
 /**
- * @param {PrintNode | null} node a statement, or a loop's head
+ * @param {PrintNode | null | undefined} node a statement, or a loop's head, which a compressed `for` may lack
  * @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 !== undefined &&
 	(node.type === "VariableDeclaration"
 		? node.kind !== "var" &&
 			node.declarations.some((declarator) =>
@@ -1993,7 +2021,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 		) {
 			return;
 		}
-		names.identifiers.push(/** @type {PrintIdentifier} */ (identifier));
+		names.identifiers.push(identifier);
 		names.spellings.push(spelling);
 		names.savings.push(saving);
 	}
@@ -2030,12 +2058,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 	 * @returns {MinifierScope} the scope, now current
 	 */
 	_open(type, node, isVarScope) {
-		const scope = new MinifierScope(
-			type,
-			node,
-			/** @type {MinifierScope} */ (this.scope),
-			isVarScope
-		);
+		const scope = new MinifierScope(type, node, this.scope, isVarScope);
 		this.scope = scope;
 		return scope;
 	}
@@ -2047,7 +2070,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 	 * @returns {MinifierScope} the scope it leaves, now the new scope's parent
 	 */
 	_enterBlock(type, node) {
-		const outer = /** @type {MinifierScope} */ (this.scope);
+		const outer = this.scope;
 		this._open(type, node, false).usesWith = outer.usesWith;
 		return outer;
 	}
@@ -2169,7 +2192,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 	_addReference(node, flags) {
 		if (this.release !== undefined) this.release(node);
 		this.referenceNodes.push(node);
-		this.referenceScopes.push(/** @type {MinifierScope} */ (this.scope));
+		this.referenceScopes.push(this.scope);
 		this.referenceFlags.push(flags);
 	}
 
@@ -2244,7 +2267,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 	 */
 	_declare(identifier, kind) {
 		const { name } = identifier;
-		const scope = /** @type {MinifierScope} */ (this.scope);
+		const scope = this.scope;
 		if (kind === DECLARES_IMPORT) {
 			this._defineVariable(scope, identifier, name, kind);
 			return;
@@ -2381,7 +2404,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 	 */
 	_visitMinifierFunction(node) {
 		const outerStrict = this.strict;
-		const outer = /** @type {MinifierScope} */ (this.scope);
+		const outer = this.scope;
 		const outerLabels = this.labelsInScope;
 		const stack = this.stack;
 		const inBlock =
@@ -2448,7 +2471,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 	 */
 	_visitMinifierClass(node) {
 		const outerStrict = this.strict;
-		const outer = /** @type {MinifierScope} */ (this.scope);
+		const outer = this.scope;
 		const outerLabels = this.labelsInScope;
 		this.stack.push(node);
 		this.strict = true;
@@ -2572,7 +2595,9 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 	 */
 	_visit(node) {
 		// the shared walk's way back in, for the children of what it reads
-		this._visitPrint(/** @type {PrintNode} */ (/** @type {unknown} */ (node)));
+		this._visitPrint(
+			/** @type {PrintNode} */ (/** @type {PrintNode | Node} */ (node))
+		);
 	}
 
 	/**
@@ -2683,7 +2708,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 					current
 				);
 				if (this.safari10 && current.type.startsWith("For")) {
-					this.forScopes.push(/** @type {MinifierScope} */ (this.scope));
+					this.forScopes.push(this.scope);
 				}
 				this._visitLoop(current);
 				this.scope = outer;
@@ -2706,7 +2731,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 			case "CatchClause": {
 				stack.push(current);
 				const outer = this._enterBlock("catch", current);
-				const catchScope = /** @type {MinifierScope} */ (this.scope);
+				const catchScope = this.scope;
 				const ranged = this.parameterScopes && Boolean(current.param);
 				if (ranged) {
 					catchScope.parameterStart = this.referenceNodes.length;
@@ -2824,7 +2849,9 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 			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)));
+				super._visit(
+					/** @type {Node} */ (/** @type {Node | PrintNode} */ (current))
+				);
 				stack.pop();
 				return;
 			case "PrivateIdentifier":
@@ -2997,7 +3024,7 @@ class MinifierScopeAnalyzer extends ScopeAnalyzer {
 			const { length } = references;
 			for (let j = 0; j < length; j++) {
 				const read = /** @type {PrintIdentifier} */ (
-					/** @type {unknown} */ (references[j].identifier)
+					/** @type {PrintIdentifier | Identifier} */ (references[j].identifier)
 				);
 				read.definition = variable;
 				this._referenceVariable(
@@ -3098,7 +3125,7 @@ class MinifierTreeScopeAnalyzer {
 		/** @type {MinifierScope} */
 		this.toplevel = new MinifierScope(
 			"global",
-			/** @type {PrintNode} */ (/** @type {unknown} */ (program)),
+			/** @type {PrintNode} */ (/** @type {PrintNode | number} */ (program)),
 			null,
 			true
 		);
@@ -3167,7 +3194,7 @@ class MinifierTreeScopeAnalyzer {
 		) {
 			return;
 		}
-		/** @type {unknown} */
+		/** @type {ReturnType<SyntaxTree["value"]>} */
 		let spelling;
 		if (types[spelled] === NodeType.Identifier) {
 			spelling = tree.name(spelled);
@@ -3282,7 +3309,7 @@ class MinifierTreeScopeAnalyzer {
 	_open(type, node, isVarScope) {
 		const scope = new MinifierScope(
 			type,
-			/** @type {PrintNode} */ (/** @type {unknown} */ (node)),
+			/** @type {PrintNode} */ (/** @type {PrintNode | number} */ (node)),
 			this.scope,
 			isVarScope
 		);
@@ -3603,7 +3630,9 @@ class MinifierTreeScopeAnalyzer {
 	_keepsInBlock(scope, name) {
 		const { tree } = this;
 		while (scope !== scope.variableScope) {
-			const node = /** @type {number} */ (/** @type {unknown} */ (scope.node));
+			const node = /** @type {number} */ (
+				/** @type {number | PrintNode} */ (scope.node)
+			);
 			switch (this.types[node]) {
 				case NodeType.BlockStatement:
 					if (this._listDeclaresLexically(node, Field.body, name)) return true;
@@ -3648,7 +3677,9 @@ class MinifierTreeScopeAnalyzer {
 			}
 			scope = /** @type {MinifierScope} */ (scope.upper);
 		}
-		const node = /** @type {number} */ (/** @type {unknown} */ (scope.node));
+		const node = /** @type {number} */ (
+			/** @type {number | PrintNode} */ (scope.node)
+		);
 		if (this.types[node] === NodeType.Program) {
 			return this._listDeclaresLexically(node, Field.body, name);
 		}
@@ -4285,7 +4316,7 @@ class MinifierTreeScopeAnalyzer {
 		return identifiers.map(
 			(identifier) =>
 				/** @type {PrintIdentifier} */ (
-					/** @type {unknown} */ ({
+					/** @type {PrintIdentifier | { name: string, definition: TreeDefinition }} */ ({
 						name: this.tree.name(identifier),
 						definition: this.definitions[identifier]
 					})
@@ -4383,7 +4414,9 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	 */
 	constructor(root, options, raise, dialect, parentScope, toplevel) {
 		super(
-			/** @type {PrintProgram} */ (/** @type {unknown} */ (root)),
+			/** @type {PrintProgram} */ (
+				/** @type {PrintProgram | CompressorNode} */ (root)
+			),
 			{
 				ie8: options.ie8,
 				safari10: options.safari10,
@@ -4396,18 +4429,20 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 		/** @type {CompressorDialect} */
 		this.dialect = dialect;
 		this.toplevel = /** @type {MinifierScope} */ (
-			/** @type {unknown} */ (toplevel)
+			/** @type {MinifierScope | CompressorScopeShape} */ (toplevel)
 		);
 		this.tokenTables =
-			/** @type {PrintProgram} */ (/** @type {unknown} */ (toplevel.node))
-				.tokenTables || undefined;
+			/** @type {PrintProgram} */ (
+				/** @type {PrintProgram | CompressorNode} */ (toplevel.node)
+			).tokenTables || undefined;
 		this.scope = /** @type {MinifierScope} */ (
-			/** @type {unknown} */ (parentScope)
+			/** @type {MinifierScope | CompressorScopeShape} */ (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
+			/** @type {Map<string, MinifierVariable> | Map<string, CompressorDefinition>} */ (
+				toplevel.node.globals
+			)
 		);
 	}
 
@@ -4419,19 +4454,21 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	 */
 	_open(type, node, isVarScope) {
 		const opener = /** @type {CompressorNode} */ (
-			/** @type {unknown} */ (node)
+			/** @type {CompressorNode | PrintNode} */ (node)
 		);
 		const scope = createCompressorScope(
 			type,
 			opener,
 			/** @type {CompressorScopeShape | null} */ (
-				/** @type {unknown} */ (this.scope)
+				/** @type {CompressorScopeShape | MinifierScope | null} */ (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));
+		this.scope = /** @type {MinifierScope} */ (
+			/** @type {MinifierScope | CompressorScopeShape} */ (scope)
+		);
 		return this.scope;
 	}
 
@@ -4446,10 +4483,10 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	 */
 	_addDeclaration(target, variable, identifier, name, kind) {
 		const scope = /** @type {CompressorScopeShape} */ (
-			/** @type {unknown} */ (target)
+			/** @type {CompressorScopeShape | MinifierScope} */ (target)
 		);
 		const opener = /** @type {CompressorNode} */ (
-			/** @type {unknown} */ (/** @type {MinifierScope} */ (this.scope).node)
+			/** @type {CompressorNode | PrintNode} */ (this.scope.node)
 		);
 		/** @type {CompressorNode | null | undefined} */
 		let init;
@@ -4458,13 +4495,11 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 			symbol = this.dialect.argumentsSymbol(opener);
 		} else {
 			symbol = /** @type {CompressorNode} */ (
-				/** @type {unknown} */ (identifier)
+				/** @type {CompressorNode | PrintIdentifier} */ (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)
-				);
+				symbol.scope = scope;
 				// A function expression named `arguments` is not its own value.
 				init =
 					kind === DECLARES_LAMBDA && name === "arguments" ? undefined : opener;
@@ -4473,14 +4508,16 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 			}
 		}
 		let definition = /** @type {CompressorDefinition | undefined} */ (
-			/** @type {unknown} */ (variable)
+			/** @type {CompressorDefinition | MinifierVariable | undefined} */ (
+				variable
+			)
 		);
 		if (definition !== undefined) {
 			definition.declarations |= 1 << kind;
 			definition.identifiers.push(symbol);
 			if (
 				definition.init &&
-				(definition.scope !== /** @type {unknown} */ (symbol.scope) ||
+				(definition.scope !== symbol.scope ||
 					this.dialect.isFunction(definition.init))
 			) {
 				definition.init = init;
@@ -4498,7 +4535,7 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 		}
 		symbol.definition = definition;
 		return /** @type {MinifierVariable} */ (
-			/** @type {unknown} */ (definition)
+			/** @type {MinifierVariable | CompressorDefinition} */ (definition)
 		);
 	}
 
@@ -4511,9 +4548,11 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	 */
 	_referenceVariable(identifier, from, variable) {
 		/** @type {CompressorDefinition} */ (
-			/** @type {unknown} */ (variable)
+			/** @type {CompressorDefinition | MinifierVariable} */ (variable)
 		).references.push(
-			/** @type {CompressorNode} */ (/** @type {unknown} */ (identifier))
+			/** @type {CompressorNode} */ (
+				/** @type {CompressorNode | PrintIdentifier} */ (identifier)
+			)
 		);
 		encloseVariable(from, variable);
 	}
@@ -4525,8 +4564,11 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	 * @returns {void}
 	 */
 	_declare(identifier, kind) {
-		/** @type {CompressorNode} */ (/** @type {unknown} */ (identifier)).scope =
-			/** @type {CompressorNode} */ (/** @type {unknown} */ (this.scope));
+		/** @type {CompressorNode} */ (
+			/** @type {CompressorNode | PrintIdentifier} */ (identifier)
+		).scope = /** @type {CompressorScopeShape} */ (
+			/** @type {CompressorScopeShape | MinifierScope} */ (this.scope)
+		);
 		super._declare(identifier, kind);
 	}
 
@@ -4549,12 +4591,10 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	 */
 	_recordScope(node) {
 		if (node === null || node === undefined) return;
-		const symbol = /** @type {CompressorNode} */ (
-			/** @type {unknown} */ (node)
-		);
+		const symbol = /** @type {CompressorNode} */ (node);
 		if (this.dialect.isSymbol(symbol)) {
-			symbol.scope = /** @type {CompressorNode} */ (
-				/** @type {unknown} */ (this.scope)
+			symbol.scope = /** @type {CompressorScopeShape} */ (
+				/** @type {CompressorScopeShape | MinifierScope} */ (this.scope)
 			);
 		}
 	}
@@ -4567,7 +4607,7 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	 */
 	_visitPrint(current) {
 		const node = /** @type {CompressorNode} */ (
-			/** @type {unknown} */ (current)
+			/** @type {CompressorNode | PrintNode} */ (current)
 		);
 		switch (current.type) {
 			case "Identifier":
@@ -4584,7 +4624,9 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 				if (
 					!current.computed &&
 					!this.dialect.isObjectKeyValue(
-						/** @type {CompressorNode} */ (/** @type {unknown} */ (current))
+						/** @type {CompressorNode} */ (
+							/** @type {CompressorNode | PrintNode} */ (current)
+						)
 					)
 				) {
 					this._recordScope(current.key);
@@ -4594,7 +4636,9 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 				if (
 					!current.computed &&
 					!this.dialect.isPrivateField(
-						/** @type {CompressorNode} */ (/** @type {unknown} */ (current))
+						/** @type {CompressorNode} */ (
+							/** @type {CompressorNode | PrintNode} */ (current)
+						)
 					)
 				) {
 					this._recordScope(current.key);
@@ -4640,7 +4684,9 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	 * @returns {void}
 	 */
 	_visitExportAll(node) {
-		const exported = /** @type {PrintNode} */ (/** @type {unknown} */ (node));
+		const exported = /** @type {PrintNode} */ (
+			/** @type {PrintNode | CompressorNode} */ (node)
+		);
 		this._checkModuleStatement(exported, "Export");
 		/** @type {CompressorNode[]} */
 		const names = node.exported_names;
@@ -4649,7 +4695,11 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 		stack.push(exported);
 		for (let i = 0; i < names.length; i++) {
 			const mapping = names[i];
-			stack.push(/** @type {PrintNode} */ (/** @type {unknown} */ (mapping)));
+			stack.push(
+				/** @type {PrintNode} */ (
+					/** @type {PrintNode | CompressorNode} */ (mapping)
+				)
+			);
 			this._addReference(
 				/** @type {PrintIdentifier} */ (mapping.local),
 				REFERENCE_EXPORTED | REFERENCE_FROM_MODULE
@@ -4668,18 +4718,28 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 		const { label } = node;
 		const { name } = label;
 		const labels = /** @type {Map<string, CompressorNode>} */ (
-			/** @type {unknown} */ (this.labelsInScope)
+			/** @type {Map<string, CompressorNode> | Map<string, MinifierLabel>} */ (
+				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)
+			/** @type {CompressorDefinition | CompressorNode} */ (label)
 		);
 		label.references = [];
 		labels.set(name, label);
-		this.stack.push(/** @type {PrintNode} */ (/** @type {unknown} */ (node)));
-		this._visitPrint(node.body);
+		this.stack.push(
+			/** @type {PrintNode} */ (
+				/** @type {PrintNode | CompressorNode} */ (node)
+			)
+		);
+		this._visitPrint(
+			/** @type {PrintNode} */ (
+				/** @type {PrintNode | CompressorNode | CompressorNode[]} */ (node.body)
+			)
+		);
 		this.stack.pop();
 		labels.delete(name);
 	}
@@ -4694,7 +4754,9 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 		if (!name) return;
 		this._recordScope(name);
 		const label = /** @type {Map<string, CompressorNode>} */ (
-			/** @type {unknown} */ (this.labelsInScope)
+			/** @type {Map<string, CompressorNode> | Map<string, MinifierLabel>} */ (
+				this.labelsInScope
+			)
 		).get(name.name);
 		if (label === undefined) {
 			const start = /** @type {Token} */ (this.tokenOf(name.startToken));
@@ -4703,7 +4765,7 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 			);
 		}
 		name.definition = /** @type {CompressorDefinition} */ (
-			/** @type {unknown} */ (label)
+			/** @type {CompressorDefinition | CompressorNode} */ (label)
 		);
 		label.references.push(node);
 	}
@@ -4717,17 +4779,21 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 	_resolveCompressor() {
 		const { referenceNodes, referenceFlags } = this;
 		const globals = /** @type {Map<string, CompressorDefinition>} */ (
-			/** @type {unknown} */ (this.globals)
+			/** @type {Map<string, CompressorDefinition> | Map<string, MinifierVariable>} */ (
+				this.globals
+			)
 		);
 		const toplevel = /** @type {CompressorScopeShape} */ (
-			/** @type {unknown} */ (this.toplevel)
+			/** @type {CompressorScopeShape | MinifierScope} */ (this.toplevel)
 		);
 		for (let i = 0; i < referenceNodes.length; i++) {
 			const node = /** @type {CompressorNode} */ (
-				/** @type {unknown} */ (referenceNodes[i])
+				/** @type {CompressorNode | PrintIdentifier | PrintLiteral} */ (
+					referenceNodes[i]
+				)
 			);
 			const from = /** @type {MinifierScope} */ (
-				/** @type {unknown} */ (node.scope)
+				/** @type {MinifierScope | CompressorScopeShape} */ (node.scope)
 			);
 			const flags = referenceFlags[i];
 			const { name } = node;
@@ -4748,7 +4814,7 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 				}
 			}
 			let definition = /** @type {CompressorDefinition | undefined} */ (
-				/** @type {unknown} */ (
+				/** @type {CompressorDefinition | MinifierVariable | undefined} */ (
 					flags & REFERENCE_FROM_MODULE
 						? undefined
 						: findMinifierVariable(from, name, i)
@@ -4776,14 +4842,16 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 			definition.references.push(node);
 			encloseVariable(
 				from,
-				/** @type {MinifierVariable} */ (/** @type {unknown} */ (definition))
+				/** @type {MinifierVariable} */ (
+					/** @type {MinifierVariable | CompressorDefinition} */ (definition)
+				)
 			);
 			if (
 				from.variableScope !== from &&
 				((1 << definition.kind) & BLOCK_DECLARATIONS) === 0
 			) {
-				node.scope = /** @type {CompressorNode} */ (
-					/** @type {unknown} */ (from.variableScope)
+				node.scope = /** @type {CompressorScopeShape} */ (
+					/** @type {CompressorScopeShape | Scope} */ (from.variableScope)
 				);
 			}
 		}
@@ -4794,12 +4862,14 @@ class CompressorScopeAnalyzer extends MinifierScopeAnalyzer {
 		const { catchNames, catchScopes } = this;
 		for (let i = 0; i < catchNames.length; i++) {
 			const symbol = /** @type {CompressorNode} */ (
-				/** @type {unknown} */ (catchNames[i])
+				/** @type {CompressorNode | PrintIdentifier} */ (catchNames[i])
 			);
 			const { name } = symbol;
 			const { references } = symbol.definition;
 			const defunScope = /** @type {CompressorScopeShape} */ (
-				/** @type {unknown} */ (catchScopes[i].variableScope)
+				/** @type {CompressorScopeShape | Scope} */ (
+					catchScopes[i].variableScope
+				)
 			);
 			let definition = defunScope.findVariable(name) || globals.get(name);
 			if (definition === undefined) {
@@ -4874,22 +4944,28 @@ const analyzeCompressorScope = (
 	);
 	if (isProgram) {
 		analyzer.stack.push(
-			/** @type {PrintNode} */ (/** @type {unknown} */ (root))
+			/** @type {PrintNode} */ (
+				/** @type {PrintNode | CompressorNode} */ (root)
+			)
 		);
 		analyzer._visitList(
-			/** @type {PrintProgram} */ (/** @type {unknown} */ (root)).body
+			/** @type {PrintProgram} */ (
+				/** @type {PrintProgram | CompressorNode} */ (root)
+			).body
 		);
 	} else {
 		// What a declaration's `export` is read off is not there.
 		analyzer.stack.push(
 			/** @type {PrintNode} */ (
-				/** @type {unknown} */ (
+				/** @type {PrintNode | CompressorNode} */ (
 					/** @type {CompressorScopeShape} */ (parentScope).node
 				)
 			)
 		);
 		analyzer._visitPrint(
-			/** @type {PrintNode} */ (/** @type {unknown} */ (root))
+			/** @type {PrintNode} */ (
+				/** @type {PrintNode | CompressorNode} */ (root)
+			)
 		);
 	}
 	analyzer.stack.pop();