`extract_numeric_values` required two numeric literals, so arithmetic
over values with no literal form never folded: `Infinity` and `NaN`
identifiers normalize to non-finite numeric literals and fold, but
`undefined` normalizes to `void 0` — a unary expression — so
`void 0 * 2` stayed as-is, eight characters where `NaN` is three. The
same gate kept tracked constants from folding: `let a;
console.log(a * 2)` kept the read (and with it the declaration) alive
where `console.log(NaN)` is smaller and lets the binding die. terser
folds all of these; esbuild folds none. Surfaced by the review
question on #24452.

The extraction now falls back to the constant evaluator, which
applies ToNumber (`undefined` → NaN, `null` → 0, `'2'` → 2) and
refuses side-effectful operands; each arm's small-result size filters
are unchanged. A cheap operand-kind gate keeps the fallback away from
allocation-prone operands (a bigint literal heap-allocates only for
ToNumber to bail; a call expression attempts string-method folds) —
with it, the allocation snapshots are byte-identical to main.
Addition already behaved this way (`void 0 + 1` folded), so this
aligns the gated arms with it.

Widening NaN-producing folds exposed a pre-existing miscompile that
had to be fixed first: a NaN numeric literal prints as the identifier
`NaN`, so `function f() { let NaN = 1; return 0 / 0; }` minified to
`return NaN` — returning 1. `eval_binary` now bails when `NaN` /
`Infinity` is shadowed at the fold site; bailing rather than emitting
`0 / 0` keeps the fixed-point loop convergent, since replacing
`0 / 0` with itself would set the changed flag on every pass. For
non-binary producers (e.g. `parseInt` folds), `value_to_expr`
materializes non-finite constants in shadowed scopes as `0/0` /
`1/0` / `-1/0`, which the division fold then leaves alone.

## Example

```js
let a;
console.log(a * 2);
console.log(void 0 * 2);
```

Before:

```js
let a;
console.log(a * 2), console.log(void 0 * 2);
```

After:

```js
console.log(NaN), console.log(NaN);
```

Verified with the minifier unit suite (555 passing; the only
expectation changes are the closure-compiler ports this enables: the
commented-out `x = null * 1` → `x = 0` family now passes and
`x = null ** 0` folds to `x = 1`), `--twice` idempotency, and
byte-identical minsize and allocation snapshots.

Implemented with AI assistance (Claude Code); design, review, and
verification driven by the author per the repo AI-usage policy.

`extract_numeric_values` required two numeric literals, so arithmetic
over values with no literal form never folded: `Infinity` and `NaN`
identifiers normalize to non-finite numeric literals and fold, but
`undefined` normalizes to `void 0` — a unary expression — so
`void 0 * 2` stayed as-is, eight characters where `NaN` is three. The
same gate kept tracked constants from folding: `let a;
console.log(a * 2)` kept the read (and with it the declaration) alive
where `console.log(NaN)` is smaller and lets the binding die. terser
folds all of these; esbuild folds none. Surfaced by the review
question on #24452.

The extraction now falls back to the constant evaluator, which
applies ToNumber (`undefined` → NaN, `null` → 0, `'2'` → 2) and
refuses side-effectful operands; each arm's small-result size filters
are unchanged. A cheap operand-kind gate keeps the fallback away from
allocation-prone operands (a bigint literal heap-allocates only for
ToNumber to bail; a call expression attempts string-method folds) —
with it, the allocation snapshots are byte-identical to main.
Addition already behaved this way (`void 0 + 1` folded), so this
aligns the gated arms with it.

Widening NaN-producing folds exposed a pre-existing miscompile that
had to be fixed first: a NaN numeric literal prints as the identifier
`NaN`, so `function f() { let NaN = 1; return 0 / 0; }` minified to
`return NaN` — returning 1. `eval_binary` now bails when `NaN` /
`Infinity` is shadowed at the fold site; bailing rather than emitting
`0 / 0` keeps the fixed-point loop convergent, since replacing
`0 / 0` with itself would set the changed flag on every pass. For
non-binary producers (e.g. `parseInt` folds), `value_to_expr`
materializes non-finite constants in shadowed scopes as `0/0` /
`1/0` / `-1/0`, which the division fold then leaves alone.

## Example

```js
let a;
console.log(a * 2);
console.log(void 0 * 2);
```

Before:

```js
let a;
console.log(a * 2), console.log(void 0 * 2);
```

After:

```js
console.log(NaN), console.log(NaN);
```

Verified with the minifier unit suite (555 passing; the only
expectation changes are the closure-compiler ports this enables: the
commented-out `x = null * 1` → `x = 0` family now passes and
`x = null ** 0` folds to `x = 1`), `--twice` idempotency, and
byte-identical minsize and allocation snapshots.

Implemented with AI assistance (Claude Code); design, review, and
verification driven by the author per the repo AI-usage policy.

`extract_numeric_values` required two numeric literals, so arithmetic
over values with no literal form never folded: `Infinity` and `NaN`
identifiers normalize to non-finite numeric literals and fold, but
`undefined` normalizes to `void 0` — a unary expression — so
`void 0 * 2` stayed as-is, eight characters where `NaN` is three. The
same gate kept tracked constants from folding: `let a;
console.log(a * 2)` kept the read (and with it the declaration) alive
where `console.log(NaN)` is smaller and lets the binding die. terser
folds all of these; esbuild folds none. Surfaced by the review
question on #24452.

The extraction now falls back to the constant evaluator, which
applies ToNumber (`undefined` → NaN, `null` → 0, `'2'` → 2) and
refuses side-effectful operands; each arm's small-result size filters
are unchanged. A cheap operand-kind gate keeps the fallback away from
allocation-prone operands (a bigint literal heap-allocates only for
ToNumber to bail; a call expression attempts string-method folds) —
with it, the allocation snapshots are byte-identical to main.
Addition already behaved this way (`void 0 + 1` folded), so this
aligns the gated arms with it.

Widening NaN-producing folds exposed a pre-existing miscompile that
had to be fixed first: a NaN numeric literal prints as the identifier
`NaN`, so `function f() { let NaN = 1; return 0 / 0; }` minified to
`return NaN` — returning 1. `eval_binary` now bails when `NaN` /
`Infinity` is shadowed at the fold site; bailing rather than emitting
`0 / 0` keeps the fixed-point loop convergent, since replacing
`0 / 0` with itself would set the changed flag on every pass. For
non-binary producers (e.g. `parseInt` folds), `value_to_expr`
materializes non-finite constants in shadowed scopes as `0/0` /
`1/0` / `-1/0`, which the division fold then leaves alone.

## Example

```js
let a;
console.log(a * 2);
console.log(void 0 * 2);
```

Before:

```js
let a;
console.log(a * 2), console.log(void 0 * 2);
```

After:

```js
console.log(NaN), console.log(NaN);
```

Verified with the minifier unit suite (555 passing; the only
expectation changes are the closure-compiler ports this enables: the
commented-out `x = null * 1` → `x = 0` family now passes and
`x = null ** 0` folds to `x = 1`), `--twice` idempotency, and
byte-identical minsize and allocation snapshots.

Implemented with AI assistance (Claude Code); design, review, and
verification driven by the author per the repo AI-usage policy.

)

`extract_numeric_values` required two numeric literals, so arithmetic over values with no literal form never folded: `Infinity` and `NaN` identifiers normalize to non-finite numeric literals and fold, but `undefined` normalizes to `void 0` — a unary expression — so `void 0 * 2` stayed as-is, eight characters where `NaN` is three. The same gate kept tracked constants from folding: `let a; console.log(a * 2)` kept the read (and with it the declaration) alive where `console.log(NaN)` is smaller and lets the binding die. terser folds all of these; esbuild folds none. Surfaced by the review question on #24452.

The extraction now falls back to the constant evaluator, which applies ToNumber (`undefined` → NaN, `null` → 0, `'2'` → 2) and refuses side-effectful operands; each arm's small-result size filters are unchanged. A cheap operand-kind gate keeps the fallback away from allocation-prone operands (a bigint literal heap-allocates only for ToNumber to bail; a call expression attempts string-method folds) — with it, the allocation snapshots are byte-identical to main. Addition already behaved this way (`void 0 + 1` folded), so this aligns the gated arms with it.

Widening NaN-producing folds exposed a pre-existing miscompile that had to be fixed first: a NaN numeric literal prints as the identifier `NaN`, so `function f() { let NaN = 1; return 0 / 0; }` minified to `return NaN` — returning 1. `eval_binary` now bails when `NaN` / `Infinity` is shadowed at the fold site; bailing rather than emitting `0 / 0` keeps the fixed-point loop convergent, since replacing `0 / 0` with itself would set the changed flag on every pass. For non-binary producers (e.g. `parseInt` folds), `value_to_expr` materializes non-finite constants in shadowed scopes as `0/0` / `1/0` / `-1/0`, which the division fold then leaves alone.

## Example

```js
let a;
console.log(a * 2);
console.log(void 0 * 2);
```

Before:

```js
let a;
console.log(a * 2), console.log(void 0 * 2);
```

After:

```js
console.log(NaN), console.log(NaN);
```

Verified with the minifier unit suite (555 passing; the only expectation changes are the closure-compiler ports this enables: the commented-out `x = null * 1` → `x = 0` family now passes and `x = null ** 0` folds to `x = 1`), `--twice` idempotency, and byte-identical minsize and allocation snapshots.

Fixes #24474

Implemented with AI assistance (Claude Code); design, review, and verification driven by the author per the repo AI-usage policy.

)

`extract_numeric_values` required two numeric literals, so arithmetic over values with no literal form never folded: `Infinity` and `NaN` identifiers normalize to non-finite numeric literals and fold, but `undefined` normalizes to `void 0` — a unary expression — so `void 0 * 2` stayed as-is, eight characters where `NaN` is three. The same gate kept tracked constants from folding: `let a; console.log(a * 2)` kept the read (and with it the declaration) alive where `console.log(NaN)` is smaller and lets the binding die. terser folds all of these; esbuild folds none. Surfaced by the review question on #24452.

The extraction now falls back to the constant evaluator, which applies ToNumber (`undefined` → NaN, `null` → 0, `'2'` → 2) and refuses side-effectful operands; each arm's small-result size filters are unchanged. A cheap operand-kind gate keeps the fallback away from allocation-prone operands (a bigint literal heap-allocates only for ToNumber to bail; a call expression attempts string-method folds) — with it, the allocation snapshots are byte-identical to main. Addition already behaved this way (`void 0 + 1` folded), so this aligns the gated arms with it.

Widening NaN-producing folds exposed a pre-existing miscompile that had to be fixed first: a NaN numeric literal prints as the identifier `NaN`, so `function f() { let NaN = 1; return 0 / 0; }` minified to `return NaN` — returning 1. `eval_binary` now bails when `NaN` / `Infinity` is shadowed at the fold site; bailing rather than emitting `0 / 0` keeps the fixed-point loop convergent, since replacing `0 / 0` with itself would set the changed flag on every pass. For non-binary producers (e.g. `parseInt` folds), `value_to_expr` materializes non-finite constants in shadowed scopes as `0/0` / `1/0` / `-1/0`, which the division fold then leaves alone.

## Example

```js
let a;
console.log(a * 2);
console.log(void 0 * 2);
```

Before:

```js
let a;
console.log(a * 2), console.log(void 0 * 2);
```

After:

```js
console.log(NaN), console.log(NaN);
```

Verified with the minifier unit suite (555 passing; the only expectation changes are the closure-compiler ports this enables: the commented-out `x = null * 1` → `x = 0` family now passes and `x = null ** 0` folds to `x = 1`), `--twice` idempotency, and byte-identical minsize and allocation snapshots.

Fixes #24474

Implemented with AI assistance (Claude Code); design, review, and verification driven by the author per the repo AI-usage policy.