webfuscator 1.3.0 → 1.3.1

package/src/transforms/const-let-to-var.ts

@@ -3,14 +3,11 @@ import type { NodePath, Scope, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { initializerReaches } from '../analysis/document-order'
-import { isInsideWith } from '../utils/ast'
-import { hasConstantViolation } from '../utils/paths'
-
 /**
- * Converts safe `let` and `const` declarations to `var` and renames bindings
- * that would conflict after hoisting. It skips TDZ reads, reassigned constants,
- * captured loop bindings, uninitialized loop heads, script globals, and `with`.
+ * Converts `let` and `const` declarations to `var` and renames bindings that
+ * would conflict after hoisting. It leaves loop declarations unchanged when
+ * `var` would lose a captured per-iteration binding or reuse the previous
+ * iteration's value.
  *
  * @example
  * // ◀️ before
@@ -33,36 +30,12 @@ export function constLetToVar(ast: File): boolean {
       if (kind !== 'let' && kind !== 'const') {
         return
       }
-      // Babel's scope table cannot account for properties supplied by `with`.
-      if (isInsideWith(path)) {
-        return
-      }
-      // A `var` write would lose the `const` TypeError.
-      if (kind === 'const' && hasConstantViolation(path)) {
-        return
-      }
-      // Hoisted `var` reads `undefined` where a lexical binding throws in TDZ.
-      if (hasTdzRiskyReference(path)) {
-        return
-      }
       // An uninitialized lexical loop head resets on each entry. `var` does not.
       if (forHeadMissingInitializer(path)) {
         return
       }
       const blockScope = path.scope
       const varScope = blockScope.getFunctionParent() ?? blockScope.getProgramParent()
-      if (varScope.path.isProgram()) {
-        // Script `var` creates a global-object property; module `var` does not.
-        if (varScope.path.node.sourceType !== 'module') {
-          return
-        }
-        // A circular importer can read this binding before initialization. A
-        // lexical binding throws in TDZ then, while `var` reads `undefined`. That
-        // external read does not appear in this file's references.
-        if (bindsExportedName(path)) {
-          return
-        }
-      }
       // One `var` cannot preserve per-iteration bindings captured by closures.
       if (capturedInEnclosingLoop(path)) {
         return
@@ -76,10 +49,6 @@ export function constLetToVar(ast: File): boolean {
       if (!id) {
         return
       }
-      if (isInsideWith(path)) {
-        return
-      }
-
       const scope = path.parentPath.scope
       if (!isVarScope(scope) && scope.parent!.hasBinding(id.name, { noUids: true })) {
         path.scope.rename(id.name)
@@ -107,35 +76,6 @@ const conflictingFunctionsVisitor: Visitor<{ names: string[] }> = {
   },
 }
 
-// Same-scope uses need a reachable initializer. Nested uses also need their
-// function value created after initialization.
-function hasTdzRiskyReference(path: NodePath<t.VariableDeclaration>): boolean {
-  const declHome = nearestFunctionOrProgram(path)
-  for (const name of Object.keys(path.getBindingIdentifiers())) {
-    const binding = path.scope.getBinding(name)
-    if (!binding) {
-      continue
-    }
-    for (const usage of [...binding.referencePaths, ...binding.constantViolations]) {
-      if (usage.findParent((ancestor) => ancestor === path)) {
-        return true
-      }
-      const usageHome = nearestFunctionOrProgram(usage)
-      if (usageHome === declHome) {
-        if (!initializerReaches(path, usage)) {
-          return true
-        }
-        continue
-      }
-      const nested = outermostNestedFunction(usage, declHome)
-      if (!nested || nested.isFunctionDeclaration() || !initializerReaches(path, nested)) {
-        return true
-      }
-    }
-  }
-  return false
-}
-
 function forHeadMissingInitializer(path: NodePath<t.VariableDeclaration>): boolean {
   if (!t.isForStatement(path.parent) || path.key !== 'init') {
     return false
@@ -143,26 +83,6 @@ function forHeadMissingInitializer(path: NodePath<t.VariableDeclaration>): boole
   return path.node.declarations.some((decl) => decl.init == null)
 }
 
-// A source clause re-exports another module's binding, not this local binding.
-function bindsExportedName(path: NodePath<t.VariableDeclaration>): boolean {
-  if (path.parentPath.isExportNamedDeclaration()) {
-    return true
-  }
-  const names = new Set(Object.keys(path.getBindingIdentifiers()))
-  const program = path.scope.getProgramParent().path.node as t.Program
-  for (const statement of program.body) {
-    if (!t.isExportNamedDeclaration(statement) || statement.source) {
-      continue
-    }
-    for (const specifier of statement.specifiers) {
-      if (t.isExportSpecifier(specifier) && names.has(specifier.local.name)) {
-        return true
-      }
-    }
-  }
-  return false
-}
-
 // A nested function or class can observe the loop's per-iteration binding.
 function capturedInEnclosingLoop(path: NodePath<t.VariableDeclaration>): boolean {
   const loop = enclosingLoop(path)
@@ -174,7 +94,11 @@ function capturedInEnclosingLoop(path: NodePath<t.VariableDeclaration>): boolean
     if (!binding) {
       continue
     }
-    for (const usage of [...binding.referencePaths, ...binding.constantViolations]) {
+    const usages =
+      binding.kind === 'const'
+        ? binding.referencePaths
+        : [...binding.referencePaths, ...binding.constantViolations]
+    for (const usage of usages) {
       for (
         let current = usage.parentPath;
         current && current !== loop;
@@ -232,21 +156,6 @@ function transformBlockScopedVariable(
   })
 }
 
-function nearestFunctionOrProgram(path: NodePath): NodePath {
-  return path.findParent((ancestor) => ancestor.isFunction() || ancestor.isProgram())!
-}
-
-// The shallowest nested function decides when this use can run.
-function outermostNestedFunction(usage: NodePath, home: NodePath): NodePath | null {
-  let result: NodePath | null = null
-  for (let current = usage.parentPath; current && current !== home; current = current.parentPath) {
-    if (current.isFunction()) {
-      result = current
-    }
-  }
-  return result
-}
-
 function enclosingLoop(path: NodePath): NodePath<t.Loop> | null {
   for (let current = path.parentPath; current; current = current.parentPath) {
     if (current.isFunction()) {

package/src/transforms/const-to-let.ts

@@ -3,11 +3,9 @@ import type { File } from '@babel/types'
 
 import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
-import { hasConstantViolation } from '../utils/paths'
 
 /**
- * Changes `const` to `let` when Babel finds no writes. Read-only bindings keep
- * the same scope and TDZ behavior; the declarations differ only on writes.
+ * Changes `const` declarations to `let`.
  *
  * @example
  * // ◀️ before
@@ -27,9 +25,6 @@ const visitor: Visitor<ChangeState> = {
     if (path.node.kind !== 'const') {
       return
     }
-    if (hasConstantViolation(path)) {
-      return
-    }
     path.node.kind = 'let'
     state.changed = true
   },

package/src/transforms/drop-console.ts

@@ -4,7 +4,6 @@ import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
 import { isSideEffectFree } from '../analysis/purity'
-import { isInsideWith } from '../utils/ast'
 import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
@@ -90,8 +89,7 @@ const visitor: Visitor<ChangeState> = {
     if (!t.isIdentifier(object) || object.name !== 'console') {
       return
     }
-    // `with` can supply a different `console` outside Babel's scope table.
-    if (path.scope.getBinding('console') || isInsideWith(path)) {
+    if (path.scope.getBinding('console')) {
       return
     }
     // Removing the call also removes argument and computed-key evaluation.
@@ -108,11 +106,11 @@ function callArgumentsAreInert(
   callee: t.MemberExpression | t.OptionalMemberExpression,
   path: NodePath<t.ExpressionStatement>,
 ): boolean {
-  if (callee.computed && !isSideEffectFree(callee.property, path.scope, path)) {
+  if (callee.computed && !isSideEffectFree(callee.property, path.scope)) {
     return false
   }
   for (const arg of expr.arguments) {
-    if (!t.isExpression(arg) || !isSideEffectFree(arg, path.scope, path)) {
+    if (!t.isExpression(arg) || !isSideEffectFree(arg, path.scope)) {
       return false
     }
   }

package/src/transforms/expand-binary-assignment.ts

@@ -2,7 +2,6 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isInsideWith } from '../utils/ast'
 import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
@@ -58,10 +57,6 @@ function lowerBinaryAssignment(path: NodePath<t.AssignmentExpression>): boolean
   const read = t.cloneNode(left, true)
 
   if (t.isMemberExpression(left) && t.isMemberExpression(read)) {
-    // `with` can turn a bare object name into a getter or shadow a memo temp.
-    if (isInsideWith(path)) {
-      return false
-    }
     const object = left.object
     if (t.isExpression(object)) {
       const memo = path.scope.maybeGenerateMemoised(object)

package/src/transforms/expand-logical-assignment.ts

@@ -2,7 +2,6 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isInsideWith } from '../utils/ast'
 import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
@@ -52,10 +51,6 @@ function lowerLogicalAssignment(path: NodePath<t.AssignmentExpression>): boolean
   const lhs = t.cloneNode(left, true)
 
   if (t.isMemberExpression(left) && t.isMemberExpression(lhs)) {
-    // `with` can turn a bare object name into a getter or shadow a memo temp.
-    if (isInsideWith(path)) {
-      return false
-    }
     const object = left.object
     if (t.isExpression(object)) {
       const memo = path.scope.maybeGenerateMemoised(object)

package/src/transforms/extract-object-properties.ts

@@ -3,7 +3,7 @@ import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
 import { initializerReaches } from '../analysis/document-order'
-import { isInsideWith, isProtoKey } from '../utils/ast'
+import { isProtoKey } from '../utils/ast'
 import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 import { isCalleeOrTagOf } from '../utils/paths'
@@ -172,12 +172,7 @@ function performExtraction(
   if (!binding) {
     return false
   }
-  if (!binding.constant) {
-    return false
-  }
-
-  // `with` can shadow a synthesized entry binding.
-  if (isInsideWith(path)) {
+  if (path.node.kind !== 'const' && !binding.constant) {
     return false
   }
 
@@ -196,15 +191,11 @@ function performExtraction(
   const seenMembers = new Set<t.MemberExpression>()
 
   for (const ref of binding.referencePaths) {
-    // Before initialization, a wrapper read throws while a bare binding may not.
-    if (!initializerReaches(path, ref)) {
+    // A pre-initializer `var` wrapper read sees `undefined`, while an extracted
+    // binding read would not perform the member access.
+    if (path.node.kind === 'var' && !initializerReaches(path, ref)) {
       return false
     }
-    // `with` can redirect the rewritten reference.
-    if (isInsideWith(ref)) {
-      return false
-    }
-
     const parent = ref.parentPath
     if (!parent || !parent.isMemberExpression()) {
       return false

package/src/transforms/fold-builtin-methods.ts

@@ -5,7 +5,7 @@ import type { File } from '@babel/types'
 
 import { evaluateConstant, isOpaque } from '../analysis/constant'
 import { isSideEffectFree } from '../analysis/purity'
-import { isInDirectivePrologue, isInsideWith } from '../utils/ast'
+import { isInDirectivePrologue } from '../utils/ast'
 import type { ChangeState } from '../utils/change-tracking'
 import { valueToLiteral } from '../utils/literal'
 
@@ -507,7 +507,7 @@ function replaceWithPreservedExpression(
   expression: t.Expression,
   result: t.Expression,
 ): void {
-  if (!isSideEffectFree(expression, path.scope, path)) {
+  if (!isSideEffectFree(expression, path.scope)) {
     path.replaceWith(t.sequenceExpression([expression, result]))
     return
   }
@@ -527,7 +527,7 @@ function foldArrayLiteralLength(
   }
   const effects = array.elements.filter(
     (element): element is t.Expression =>
-      element !== null && t.isExpression(element) && !isSideEffectFree(element, path.scope, path),
+      element !== null && t.isExpression(element) && !isSideEffectFree(element, path.scope),
   )
   const length = t.numericLiteral(array.elements.length)
   path.replaceWith(effects.length === 0 ? length : t.sequenceExpression([...effects, length]))
@@ -555,10 +555,6 @@ function foldStringIndex(
 }
 
 function handleCall(path: NodePath<t.CallExpression>, patchedRoots: Set<string>): void {
-  // `with` can replace an intrinsic that Babel treats as an unbound global.
-  if (isInsideWith(path)) {
-    return
-  }
   const callee = path.node.callee
 
   if (t.isIdentifier(callee)) {
@@ -606,11 +602,6 @@ function handleMember(path: NodePath<t.MemberExpression>, patchedRoots: Set<stri
   if (isReferenceRequiredPosition(path)) {
     return
   }
-  // Delay the ancestor walk until cheap shape checks pass.
-  if (isInsideWith(path)) {
-    return
-  }
-
   const obj = path.node.object
 
   if (t.isIdentifier(obj) && !path.scope.getBinding(obj.name) && !patchedRoots.has(obj.name)) {

package/src/transforms/fold-constants.ts

@@ -190,7 +190,7 @@ function tryReassociateCommutative(path: NodePath<t.BinaryExpression>, op: Commu
   }
   // Grouping constants can move one operand's coercion past another operand's
   // evaluation. Multiple non-constant operands must therefore be pure.
-  if (others.length > 1 && !others.every((leaf) => isPure(leaf, path.scope, path))) {
+  if (others.length > 1 && !others.every((leaf) => isPure(leaf, path.scope))) {
     return false
   }
 
@@ -296,7 +296,7 @@ function tryReassociateSubtract(path: NodePath<t.BinaryExpression>): boolean {
   }
   // Reassociation can move `base` coercion past a subtractee's evaluation.
   // Non-constant subtractees must be pure.
-  if (!otherSubs.every((leaf) => isPure(leaf, path.scope, path))) {
+  if (!otherSubs.every((leaf) => isPure(leaf, path.scope))) {
     return false
   }
   const sum = combineConstants(constSubs, '+')

package/src/transforms/function-declaration-to-expression.ts

@@ -6,14 +6,13 @@ import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
 /**
- * Rewrites safe function declarations as `var` initializers. The function value
- * is no longer hoisted, so nothing may observe the binding before assignment.
+ * Rewrites function declarations at script top level or directly inside a
+ * function body as `var` initializers. It leaves a declaration unchanged when
+ * an earlier statement could execute user code before the assignment.
  *
- * Preceding statements must be inert. Name inference and recursive references
- * still use the `var` binding.
+ * Name inference and recursive references still use the `var` binding.
  *
- * Block-level declarations and module top-level declarations stay unchanged due
- * to Annex B aliases and live exports.
+ * Block-level and module top-level declarations stay unchanged.
  *
  * @example
  * // ◀️ before

package/src/transforms/hoist-variables.ts

@@ -9,8 +9,7 @@ import type { ChangeState } from '../utils/change-tracking'
  * Moves `var` declarations to the start of their var scope without moving
  * initializer evaluation.
  *
- * Direct exports and declarations inside `with` stay in place. Static blocks
- * keep separate declarations.
+ * Direct exports stay in place. Static blocks keep separate declarations.
  *
  * @example
  * // ◀️ before
@@ -43,7 +42,7 @@ export function hoistVariables(ast: File): boolean {
         return
       }
       const owner = ownerPath(path)
-      if (owner === null || isInsideOwnerWith(path, owner)) {
+      if (owner === null) {
         return
       }
 
@@ -98,15 +97,6 @@ function ownerPath(path: NodePath<t.VariableDeclaration>): OwnerPath | null {
   return null
 }
 
-function isInsideOwnerWith(path: NodePath, owner: OwnerPath): boolean {
-  for (let current = path.parentPath; current && current !== owner; current = current.parentPath) {
-    if (current.isWithStatement()) {
-      return true
-    }
-  }
-  return false
-}
-
 function hoistedScope(scopes: Map<t.Node, HoistedScope>, owner: OwnerPath): HoistedScope {
   const existing = scopes.get(owner.node)
   if (existing) {

package/src/transforms/inline-functions.ts

@@ -6,10 +6,10 @@ import type { File } from '@babel/types'
 import { analyzeInlineability } from '../analysis/inlineability'
 import type { InlineCandidate } from '../analysis/inlineability'
 import { isPure } from '../analysis/purity'
-import { isInsideWith, walkOwnFunctionScope } from '../utils/ast'
+import { walkOwnFunctionScope } from '../utils/ast'
 import { reorderableToStatement } from '../utils/evaluation-order'
 import { generateLoopLabel } from '../utils/loop-lowering'
-import { hasAnnexBFunctionAlias, isInStrictContext } from '../utils/paths'
+import { isInStrictContext } from '../utils/paths'
 
 /**
  * Replaces eligible calls with function bodies, working from inner calls out.
@@ -135,13 +135,6 @@ function isSafeAtCallSite(
   callPath: NodePath<t.CallExpression>,
   candidates: Map<string, InlineCandidate>,
 ): boolean {
-  // `with` and Annex B aliases can resolve a free name outside Babel's scope table.
-  if (isInsideWith(callPath)) {
-    return false
-  }
-  if (annexBHoistShadowsFreeVar(callPath, freeVars)) {
-    return false
-  }
   // Spliced code inherits call-site strictness, so it must match the callee.
   if (isInStrictContext(candidate.fnPath) !== isInStrictContext(callPath)) {
     return false
@@ -192,32 +185,6 @@ function isSafeAtCallSite(
   return true
 }
 
-// ECMA-262 B.3.2.1 creates a sloppy block-function alias that Babel misses in
-// the enclosing scope.
-function annexBHoistShadowsFreeVar(
-  callPath: NodePath<t.CallExpression>,
-  freeVars: Set<string>,
-): boolean {
-  if (freeVars.size === 0 || isInStrictContext(callPath)) {
-    return false
-  }
-  const owner = callPath.getFunctionParent() ?? callPath.scope.getProgramParent().path
-  let found = false
-  owner.traverse({
-    Function(path) {
-      path.skip()
-    },
-    FunctionDeclaration(path) {
-      const id = path.node.id
-      if (id && freeVars.has(id.name) && hasAnnexBFunctionAlias(path)) {
-        found = true
-        path.stop()
-      }
-    },
-  })
-  return found
-}
-
 // Only loops in the same function repeat the spliced body.
 function callIsInsideLoop(callPath: NodePath): boolean {
   for (let current: NodePath | null = callPath.parentPath; current; current = current.parentPath) {
@@ -580,7 +547,9 @@ function inlineCallSite(
     const replacement: t.Statement[] = []
     if (directTarget.kind === 'declarator') {
       replacement.push(
-        t.variableDeclaration('var', [t.variableDeclarator(t.identifier(directTarget.name))]),
+        t.variableDeclaration(directTarget.declarationKind, [
+          t.variableDeclarator(t.identifier(directTarget.name)),
+        ]),
       )
     }
     if (needsLabel) {
@@ -620,7 +589,9 @@ function inlineCallSite(
   return true
 }
 
-type DirectTarget = { kind: 'declarator'; name: string } | { kind: 'assign'; name: string }
+type DirectTarget =
+  | { kind: 'declarator'; name: string; declarationKind: 'let' | 'var' }
+  | { kind: 'assign'; name: string }
 
 function identifyDirectAssignmentTarget(
   callPath: NodePath<t.CallExpression>,
@@ -641,9 +612,8 @@ function identifyDirectAssignmentTarget(
     if (!declPath || !declPath.isVariableDeclaration() || declPath.node.declarations.length !== 1) {
       return null
     }
-    // Only `var` can become an uninitialized direct target without changing TDZ
-    // or block scope.
-    if (declPath.node.kind !== 'var') {
+    const declarationKind = declPath.node.kind
+    if (declarationKind !== 'var' && declarationKind !== 'let') {
       return null
     }
     const owner = declPath.parentPath
@@ -666,7 +636,7 @@ function identifyDirectAssignmentTarget(
     if (argsContainIdentName(args, name)) {
       return null
     }
-    return { kind: 'declarator', name }
+    return { kind: 'declarator', name, declarationKind }
   }
 
   if (
@@ -713,10 +683,10 @@ function argEligibleForElision(argPath: NodePath, scope: Scope): boolean {
     return false
   }
   const binding = scope.getBinding(argPath.node.name)
-  if (!binding || binding.constantViolations.length > 0) {
+  if (!binding || (binding.kind !== 'const' && binding.constantViolations.length > 0)) {
     return false
   }
-  return isPure(argPath.node, scope, argPath)
+  return isPure(argPath.node, scope)
 }
 
 // Catch parameters stay scoped to their copied handlers. Counting them here
@@ -930,8 +900,8 @@ function isNonReferenceSlot(parent: t.Node, key: string): boolean {
 interface StatementWalkContext {
   insideNestedLoop: boolean
   insideNestedSwitch: boolean
-  // Tail position propagates through final blocks, branches, and labels. Try,
-  // switch, loops, and `with` interrupt it because more code may run afterward.
+  // Tail position propagates through final blocks, branches, labels, and `with`.
+  // Try, switch, and loops interrupt it because more code may run afterward.
   tailPosition: boolean
 }
 
@@ -1051,7 +1021,7 @@ function walkIntoCompound(
   }
 
   if (t.isWithStatement(node)) {
-    node.body = walkSingleChild(node.body, hooks, { ...ctx, tailPosition: false })
+    node.body = walkSingleChild(node.body, hooks, ctx)
   }
 }
 

package/src/transforms/logical-to-ternary.ts

@@ -3,10 +3,10 @@ import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
 import { isPure } from '../analysis/purity'
-import { isInsideWith } from '../utils/ast'
 import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 import { lowerLogicalWriteStatement } from '../utils/logical-lowering'
+import { buildNonNullishCheck, buildNullishCheck } from '../utils/nullish'
 
 /**
  * Rewrites logical expressions as guarded assignments or ternaries. A
@@ -23,7 +23,7 @@ import { lowerLogicalWriteStatement } from '../utils/logical-lowering'
  * if (!x) x = b;
  * y = c;
  * if (y) y = d;
- * f((_t = get()) != null ? _t : fallback);
+ * f(((_t = get()) !== null ? _t !== void 0 : false) ? _t : fallback);
  */
 export function logicalToTernary(ast: File): boolean {
   return traverseForChanges(ast, visitor)
@@ -45,11 +45,6 @@ function lowerLogical(path: NodePath<t.LogicalExpression>): boolean {
   if (op !== '&&' && op !== '||' && op !== '??') {
     return false
   }
-  // `with` can turn repeated names into getters and shadow a cache temp.
-  if (isInsideWith(path)) {
-    return false
-  }
-
   if (lowerLogicalWriteStatement(path, (target) => buildFallbackTest(op, target))) {
     return true
   }
@@ -60,7 +55,7 @@ function lowerLogical(path: NodePath<t.LogicalExpression>): boolean {
   let valueSrc: t.Expression
 
   // Babel purity misses user coercion in unary and binary expressions.
-  if (isPure(leftPath.node, scope, leftPath)) {
+  if (isPure(leftPath.node, scope)) {
     testSrc = node.left
     valueSrc = t.cloneNode(node.left)
   } else {
@@ -71,7 +66,7 @@ function lowerLogical(path: NodePath<t.LogicalExpression>): boolean {
   }
 
   const test: t.Expression =
-    op === '??' ? t.binaryExpression('!=', testSrc, t.nullLiteral()) : testSrc
+    op === '??' ? buildNonNullishCheck(testSrc, t.cloneNode(valueSrc)) : testSrc
 
   path.replaceWith(
     op === '&&'
@@ -88,5 +83,5 @@ function buildFallbackTest(op: '&&' | '||' | '??', target: t.Identifier): t.Expr
   if (op === '&&') {
     return target
   }
-  return t.binaryExpression('==', target, t.nullLiteral())
+  return buildNullishCheck(target, t.cloneNode(target))
 }

package/src/transforms/mangle-properties.ts

@@ -13,11 +13,8 @@ import { StringGenerator } from '../utils/string-generator'
 
 /**
  * Renames statically known public properties through one program-wide mapping.
- * Property selection follows Terser, with extra collision checks for names
- * that this pipeline must leave unchanged.
- *
- * This pass runs before shape preparation, while Babel still distinguishes
- * `obj.name` from `obj["name"]`.
+ * Options select or reserve names, and collision checks keep every unchanged
+ * property distinct from the generated names.
  *
  * @example
  * // ◀️ before