webfuscator 1.3.0 → 1.3.1

package/src/transforms/nullish-coalescing-to-ternary.ts

@@ -2,15 +2,14 @@ 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'
 import { lowerLogicalWriteStatement } from '../utils/logical-lowering'
+import { buildNonNullishCheck, buildNullishCheck } from '../utils/nullish'
 
 /**
- * Rewrites `a ?? b` as a guarded assignment or `a != null ? a : b`. A
- * side-effectful left side is cached. Loose inequality checks both nullish
- * values in one comparison.
+ * Rewrites `a ?? b` as a guarded assignment or strict null and undefined
+ * checks. A side-effectful left side is cached.
  *
  * @example
  * // ◀️ before
@@ -19,8 +18,8 @@ import { lowerLogicalWriteStatement } from '../utils/logical-lowering'
  *
  * // ▶️ after
  * var x = a;
- * if (x == null) x = b;
- * f((_t = get()) != null ? _t : fallback);
+ * if (x === null ? true : x === void 0) x = b;
+ * f(((_t = get()) !== null ? _t !== void 0 : false) ? _t : fallback);
  */
 export function nullishCoalescingToTernary(ast: File): boolean {
   return traverseForChanges(ast, visitor)
@@ -39,11 +38,6 @@ function lowerNullishCoalescing(path: NodePath<t.LogicalExpression>): boolean {
   if (node.operator !== '??') {
     return false
   }
-  // `with` can turn a repeated name into a getter and shadow a cache temp.
-  if (isInsideWith(path)) {
-    return false
-  }
-
   if (lowerLogicalWriteStatement(path, nullishFallbackTest)) {
     return true
   }
@@ -64,7 +58,7 @@ function lowerNullishCoalescing(path: NodePath<t.LogicalExpression>): boolean {
 
   path.replaceWith(
     t.conditionalExpression(
-      t.binaryExpression('!=', test, t.nullLiteral()),
+      buildNonNullishCheck(test, t.cloneNode(consequent)),
       consequent,
       node.right,
     ),
@@ -73,5 +67,5 @@ function lowerNullishCoalescing(path: NodePath<t.LogicalExpression>): boolean {
 }
 
 function nullishFallbackTest(target: t.Identifier): t.Expression {
-  return t.binaryExpression('==', target, t.nullLiteral())
+  return buildNullishCheck(target, t.cloneNode(target))
 }

package/src/transforms/object-method-to-property.ts

@@ -16,7 +16,7 @@ import type { ChangeState } from '../utils/change-tracking'
  *
  * Non-computed `__proto__` methods stay intact because the property form invokes
  * ECMA-262 B.3.1 prototype-setting behavior. Computed keys create own properties
- * and remain safe.
+ * and can be rewritten.
  *
  * @example
  * // ◀️ before

package/src/transforms/optional-chaining-to-ternary.ts

@@ -2,9 +2,9 @@ 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'
+import { buildNullishCheck } from '../utils/nullish'
 
 /**
  * Rewrites optional chains as nested ternaries. Side-effectful receivers are
@@ -18,9 +18,10 @@ import type { ChangeState } from '../utils/change-tracking'
  * a?.b?.c;
  *
  * // ▶️ after
- * obj == null ? void 0 : (_m = obj.m).call(obj, arg);
- * obj == null ? true : delete obj.x;
- * a == null ? void 0 : (_b = a.b) == null ? void 0 : _b.c;
+ * (obj === null ? true : obj === void 0) ? void 0 : (_m = obj.m).call(obj, arg);
+ * (obj === null ? true : obj === void 0) ? true : delete obj.x;
+ * (a === null ? true : a === void 0) ? void 0 :
+ *   ((_b = a.b) === null ? true : _b === void 0) ? void 0 : _b.c;
  */
 export function optionalChainingToTernary(ast: File): boolean {
   return traverseForChanges(ast, visitor)
@@ -40,10 +41,6 @@ const visitor: Visitor<ChangeState> = {
 }
 
 function lowerOptionalChain(path: OptionalPath): boolean {
-  // `with` can make a repeated receiver name invoke a getter twice.
-  if (isInsideWith(path)) {
-    return false
-  }
   if (isInsideOptionalChain(path)) {
     return false
   }
@@ -173,16 +170,19 @@ function transformChain(path: OptionalPath): boolean {
     }
 
     let check: t.Expression
+    let repeatedCheck: t.Expression
 
     if (path.scope.isStatic(chain)) {
       // The receiver stays in the member expression, so the check needs its own
       // node. One node under two parents is visited twice, and a later in-place
       // rewrite such as renameIdentifiers then applies itself twice to it.
       check = t.cloneNode(chain)
+      repeatedCheck = t.cloneNode(chain)
     } else {
       const tmp = path.scope.generateUidIdentifierBasedOnNode(chain)
       path.scope.push({ id: t.cloneNode(tmp) })
       check = t.assignmentExpression('=', t.cloneNode(tmp), chain)
+      repeatedCheck = t.cloneNode(tmp)
       if (isCall) {
         ;(node as t.CallExpression).callee = t.cloneNode(tmp)
       } else {
@@ -208,7 +208,7 @@ function transformChain(path: OptionalPath): boolean {
       }
     }
 
-    const condition = t.binaryExpression('==', check, t.nullLiteral())
+    const condition = buildNullishCheck(check, repeatedCheck)
 
     let alternate = replacementPath.node as t.Expression
     if (isDelete && i === optionals.length - 1) {

package/src/transforms/pack-declarations-into-parameters.ts

@@ -6,7 +6,6 @@ import { hasDuplicateParamNames } from '../utils/ast'
 import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 import { isLiteralShaped } from '../utils/literal'
-import { hasAnnexBFunctionAlias } from '../utils/paths'
 
 /**
  * Moves leading literal-valued `var` declarations into trailing default
@@ -50,10 +49,6 @@ function packLeadingIntoParams(path: NodePath<t.Function>): boolean {
   ) {
     return false
   }
-  // An Annex B alias splits call sites across bindings Babel does not connect.
-  if (hasAnnexBFunctionAlias(path)) {
-    return false
-  }
   const params = path.node.params
   if (params.some((param) => t.isRestElement(param))) {
     return false
@@ -159,7 +154,11 @@ function methodComputedKey(path: NodePath<t.Function>): NodePath | null {
 // arity and without spread.
 function allCallSitesRespectArity(path: NodePath<t.Function>, arity: number): boolean {
   const external = functionBinding(path)
-  if (!external || !external.constant || !bindingCallsRespectArity(external, arity)) {
+  if (
+    !external ||
+    (external.kind !== 'const' && !external.constant) ||
+    !bindingCallsRespectArity(external, arity)
+  ) {
     return false
   }
   if (path.isFunctionExpression() && path.node.id) {
@@ -189,17 +188,12 @@ function bindingCallsRespectArity(binding: Binding, arity: number): boolean {
   return true
 }
 
-// Annex B can hoist function names from nested blocks into this function scope.
 function functionDeclarationNames(body: t.BlockStatement): Set<string> {
-  const names = new Set<string>()
-  t.traverseFast(body, (node) => {
-    if (t.isFunctionDeclaration(node) && node.id) {
-      names.add(node.id.name)
-      return t.traverseFast.skip
-    }
-    return node !== body && t.isFunction(node) ? t.traverseFast.skip : undefined
-  })
-  return names
+  return new Set(
+    body.body.flatMap((statement) =>
+      t.isFunctionDeclaration(statement) && statement.id ? [statement.id.name] : [],
+    ),
+  )
 }
 
 function functionBinding(path: NodePath<t.Function>): Binding | null {

package/src/transforms/pack.ts

@@ -5,7 +5,6 @@ import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
 import type { TransformContext } from '../options'
-import { isInsideWith } from '../utils/ast'
 import { isCalleeOrTagOf, isInStrictContext, referencesOrWritesVariable } from '../utils/paths'
 import { mulberry32 } from '../utils/random'
 import { StringGenerator } from '../utils/string-generator'
@@ -108,17 +107,10 @@ const STANDARD_GLOBALS: readonly string[] = [
 ]
 
 /**
- * Serializes the whole program to a string and rebuilds it at runtime through
- * the `Function` constructor. A detached function body only reaches true globals
- * and its own parameters. A free name might instead be a CommonJS `require`, a
- * bundler-injected binding, or a live import, none reachable from the body and
- * none distinguishable from a global at build time, so free names are routed
- * through a parameter object whose accessors run in the original top-level scope
- * and resolve each name there. Imports remain above the call. Names inside
- * `with` stay bare so the object still controls lookup. A Function body cannot
- * contain exports, so pack throws when it finds one. Code that needs
- * `import.meta`, top-level await, dynamic `import()`, or top-level `arguments`
- * will not run after the move.
+ * Serializes the whole program and runs it through the `Function` constructor.
+ * Imports stay outside the generated function. Reads and writes to other free
+ * names go through accessors created in the original top-level scope. Export
+ * statements are rejected because they cannot appear in a `Function` body.
  *
  * @example
  * // ◀️ before
@@ -233,11 +225,6 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
     if (name === objectName || name === 'arguments') {
       return false
     }
-    // Inside `with`, a free name may resolve to a property of the with object at
-    // runtime, so routing it to the top-level accessor would change behavior.
-    if (isInsideWith(path)) {
-      return false
-    }
     if (!referencesOrWritesVariable(path)) {
       return false
     }

package/src/transforms/remove-anonymous-function-names.ts

@@ -1,14 +1,11 @@
-import type { NodePath, Visitor } from '@babel/traverse'
-import * as t from '@babel/types'
+import type { Visitor } from '@babel/traverse'
 import type { File } from '@babel/types'
 
 import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
 /**
- * Removes a function expression's name when the body does not use its binding
- * and NamedEvaluation restores the same `.name`. Other positions could infer no
- * name or a different one.
+ * Removes a function expression's name when its body does not reference it.
  *
  * @example
  * // ◀️ before
@@ -17,7 +14,7 @@ import type { ChangeState } from '../utils/change-tracking'
  *
  * // ▶️ after
  * var greet = function () {};
- * var a = function bar() {};
+ * var a = function () {};
  */
 export function removeAnonymousFunctionNames(ast: File): boolean {
   return traverseForChanges(ast, visitor)
@@ -38,47 +35,7 @@ const visitor: Visitor<ChangeState> = {
     ) {
       return
     }
-    if (inferredName(path) !== id.name) {
-      return
-    }
     path.node.id = null
     state.changed = true
   },
 }
-
-// No inferred name means `.name` would become empty.
-function inferredName(path: NodePath<t.FunctionExpression>): string | null {
-  const node = path.node
-  const parentPath = path.parentPath
-  if (!parentPath) {
-    return null
-  }
-  const parent = parentPath.node
-  if (t.isVariableDeclarator(parent) && parent.init === node && t.isIdentifier(parent.id)) {
-    return parent.id.name
-  }
-  if (
-    t.isAssignmentExpression(parent) &&
-    parent.operator === '=' &&
-    parent.right === node &&
-    t.isIdentifier(parent.left)
-  ) {
-    return parent.left.name
-  }
-  if (t.isAssignmentPattern(parent) && parent.right === node && t.isIdentifier(parent.left)) {
-    return parent.left.name
-  }
-  if (
-    (t.isObjectProperty(parent) || t.isClassProperty(parent)) &&
-    parent.value === node &&
-    !parent.computed
-  ) {
-    if (t.isIdentifier(parent.key)) {
-      return parent.key.name
-    }
-    if (t.isStringLiteral(parent.key)) {
-      return parent.key.value
-    }
-  }
-  return null
-}

package/src/transforms/remove-unreachable-code.ts

@@ -69,41 +69,21 @@ function isCompletion(node: t.Node): boolean {
   )
 }
 
-// Hoisted bindings and referenced lexical TDZ remain observable from reachable
-// code. An unreferenced lexical declaration is inert.
 function isSafeToRemoveAfterCompletion(path: NodePath<t.Statement>): boolean {
   const node = path.node
   if (t.isFunctionDeclaration(node) || (t.isVariableDeclaration(node) && node.kind === 'var')) {
     return false
   }
-  if (t.isClassDeclaration(node) || (t.isVariableDeclaration(node) && node.kind !== 'var')) {
-    return !declaresReferencedBinding(path)
-  }
-  return !nestsHoistedDeclaration(node)
-}
-
-// A write before `let x` also observes its TDZ.
-function declaresReferencedBinding(path: NodePath<t.Statement>): boolean {
-  for (const name of Object.keys(path.getBindingIdentifiers())) {
-    const binding = path.scope.getBinding(name)
-    if (binding && (binding.references > 0 || binding.constantViolations.length > 0)) {
-      return true
-    }
-  }
-  return false
+  return !nestsHoistedVar(node)
 }
 
-function nestsHoistedDeclaration(node: t.Node): boolean {
+function nestsHoistedVar(node: t.Node): boolean {
   let found = false
   t.traverseFast(node, (child) => {
     if (found) {
       return t.traverseFast.skip
     }
     if (child !== node && t.isFunction(child)) {
-      // Function declarations may add Annex B aliases. Function bodies do not.
-      if (t.isFunctionDeclaration(child)) {
-        found = true
-      }
       return t.traverseFast.skip
     }
     if (t.isVariableDeclaration(child) && child.kind === 'var') {

package/src/transforms/remove-unused-code.ts

@@ -5,7 +5,6 @@ import type { File } from '@babel/types'
 
 import { isSideEffectFree } from '../analysis/purity'
 import type { ChangeState } from '../utils/change-tracking'
-import { hasAnnexBFunctionAlias } from '../utils/paths'
 
 /**
  * Removes unused declarations and expression statements that have no effects.
@@ -119,7 +118,7 @@ function tryRemoveDeclarator(path: NodePath<t.VariableDeclarator>): boolean {
   }
 
   const init = path.node.init
-  if (init && !isSideEffectFree(init, path.scope, path.get('init') as NodePath)) {
+  if (init && !isSideEffectFree(init, path.scope)) {
     return false
   }
 
@@ -130,7 +129,7 @@ function tryRemoveDeclarator(path: NodePath<t.VariableDeclarator>): boolean {
   if (binding.references > 0) {
     return false
   }
-  if (binding.constantViolations.length > 0) {
+  if (declaration.node.kind !== 'const' && binding.constantViolations.length > 0) {
     return false
   }
   if (path.node.init) {
@@ -148,10 +147,6 @@ function tryRemoveFunctionDecl(path: NodePath<t.FunctionDeclaration>): boolean {
   if (isExported(path)) {
     return false
   }
-  // Babel misses the sloppy Annex B alias of a block-level function.
-  if (hasAnnexBFunctionAlias(path)) {
-    return false
-  }
   const id = path.node.id
   if (!id) {
     return false
@@ -183,7 +178,7 @@ function tryRemoveClassDecl(path: NodePath<t.ClassDeclaration>): boolean {
   }
 
   // `extends`, computed keys, static fields, and static blocks run on evaluation.
-  if (path.node.superClass && !isSideEffectFree(path.node.superClass, path.scope, path)) {
+  if (path.node.superClass && !isSideEffectFree(path.node.superClass, path.scope)) {
     return false
   }
   for (const member of path.node.body.body) {
@@ -198,7 +193,7 @@ function tryRemoveClassDecl(path: NodePath<t.ClassDeclaration>): boolean {
       'computed' in member &&
       member.computed &&
       'key' in member &&
-      !isSideEffectFree(member.key, path.scope, path)
+      !isSideEffectFree(member.key, path.scope)
     ) {
       return false
     }
@@ -224,7 +219,7 @@ function tryRemoveClassDecl(path: NodePath<t.ClassDeclaration>): boolean {
 }
 
 function tryRemoveExpressionStatement(path: NodePath<t.ExpressionStatement>): boolean {
-  if (!isSideEffectFree(path.node.expression, path.scope, path.get('expression'))) {
+  if (!isSideEffectFree(path.node.expression, path.scope)) {
     return false
   }
   dereferenceSubtree(path.get('expression') as NodePath)

package/src/transforms/rename-identifiers.ts

@@ -4,15 +4,14 @@ import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
 import type { TransformContext } from '../options'
-import { isInsideWith } from '../utils/ast'
-import { hasAnnexBFunctionAlias, referencesOrWritesVariable } from '../utils/paths'
+import { referencesOrWritesVariable } from '../utils/paths'
 import { mulberry32 } from '../utils/random'
 import { StringGenerator } from '../utils/string-generator'
 
 /**
- * Renames bindings and labels with a fresh `StringGenerator`. Each scope avoids
- * live ancestor names but otherwise restarts the cursor, allowing safe reuse in
- * sibling scopes.
+ * Renames bindings and labels with the configured string generator. Generated
+ * names do not capture unresolved names or bindings still used from an outer
+ * scope. Separate sibling scopes may reuse the same names.
  *
  * @example
  * // ◀️ before
@@ -48,7 +47,6 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
   const liveAncestors = new Map<Scope, Set<Binding>>()
   // Reserve unbound names so generated bindings cannot capture them.
   const freeNames = new Set<string>()
-  // A reference inside `with` pins its binding to the source name.
   const unrenamable = new Set<Binding>()
   // Reserve pinned source names globally, including before their binding is seen.
   const pinnedNames = new Set<string>()
@@ -69,9 +67,6 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
         }
         return
       }
-      if (isInsideWith(path)) {
-        pin(binding, path.node.name)
-      }
       let scope: Scope | undefined = path.scope
       while (scope && scope !== binding.scope) {
         let live = liveAncestors.get(scope)
@@ -83,17 +78,6 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
         scope = scope.parent
       }
     },
-    FunctionDeclaration(path) {
-      // ECMA-262 B.3.3 gives sloppy block functions an alias Babel does not model.
-      if (!hasAnnexBFunctionAlias(path)) {
-        return
-      }
-      const name = path.node.id?.name
-      const binding = name === undefined ? undefined : path.scope.getBinding(name)
-      if (binding && name !== undefined) {
-        pin(binding, name)
-      }
-    },
     CatchClause(path) {
       // Babel splits a catch parameter and same-named `var` that share one runtime
       // variable. They must keep the same name.

package/src/transforms/reorder-function-declarations.ts

@@ -2,14 +2,12 @@ import type { NodePath } from '@babel/traverse'
 import type * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { hasAnnexBFunctionAlias } from '../utils/paths'
 import { rewriteStatementLists } from '../utils/statement-lists'
 import type { StatementListContainer } from '../utils/statement-lists'
 
 /**
  * Moves hoisted function declarations to the end of each program, block, switch
- * case, or static block. It keeps declaration order, including duplicate names,
- * and leaves sloppy Annex B block functions in place.
+ * case, or static block. It keeps declaration order, including duplicate names.
  *
  * If moving every declaration would turn a string expression into a directive,
  * one declaration stays before the string. Direct exports stay in place.
@@ -76,5 +74,5 @@ function createsDirective(statements: readonly t.Statement[]): boolean {
 }
 
 function isMovable(child: NodePath<t.Statement>): boolean {
-  return child.isFunctionDeclaration() && child.node.id !== null && !hasAnnexBFunctionAlias(child)
+  return child.isFunctionDeclaration() && child.node.id !== null
 }

package/src/transforms/specials-to-strings.ts

@@ -4,7 +4,6 @@ import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
 import type { TransformContext } from '../options'
-import { isInsideWith } from '../utils/ast'
 import type { ChangeState } from '../utils/change-tracking'
 import { mulberry32 } from '../utils/random'
 import { StringGenerator } from '../utils/string-generator'
@@ -69,9 +68,8 @@ const visitor: Visitor<State> = {
     if (path.scope.getBinding(name)) {
       return
     }
-    // A replacement cannot occupy a write target. `with` may also shadow `NaN`,
-    // `Infinity`, or `undefined`.
-    if (isWriteTarget(path) || isInsideWith(path)) {
+    // A replacement cannot occupy a write target.
+    if (isWriteTarget(path)) {
       return
     }
     const str = t.stringLiteral(state.generator.next())

package/src/transforms/switch-to-if.ts

@@ -47,8 +47,7 @@ const visitor: Visitor<ChangeState> = {
 
 function transformSwitch(path: NodePath<t.SwitchStatement>): boolean {
   const node = path.node
-  // Separate `if` blocks cannot preserve cross-case lexical scope or Annex B
-  // function hoisting.
+  // Separate `if` blocks cannot preserve cross-case lexical scope.
   if (hasBlockScopedDeclaration(node)) {
     return false
   }
@@ -56,7 +55,7 @@ function transformSwitch(path: NodePath<t.SwitchStatement>): boolean {
     lowerToIfElseChain(path)
     return true
   }
-  if (!labeledLoweringIsSafe(node, path.scope, path)) {
+  if (!labeledLoweringIsSafe(node, path.scope)) {
     return false
   }
   lowerToLabeledBlock(path)
@@ -69,8 +68,7 @@ function hasBlockScopedDeclaration(node: t.SwitchStatement): boolean {
       if (
         (t.isVariableDeclaration(stmt) && stmt.kind !== 'var') ||
         t.isClassDeclaration(stmt) ||
-        t.isFunctionDeclaration(stmt) ||
-        isLabeledFunctionDeclaration(stmt)
+        t.isFunctionDeclaration(stmt)
       ) {
         return true
       }
@@ -79,29 +77,14 @@ function hasBlockScopedDeclaration(node: t.SwitchStatement): boolean {
   return false
 }
 
-// Babel hides an Annex B.3.4 labeled function under LabeledStatement wrappers.
-function isLabeledFunctionDeclaration(stmt: t.Statement): boolean {
-  let current: t.Statement = stmt
-  while (t.isLabeledStatement(current)) {
-    current = current.body
-  }
-  return t.isFunctionDeclaration(current)
-}
-
 // A non-final default needs match results from later cases. Precomputing that
 // result rereads tests, so every test must be pure in this shape.
-function labeledLoweringIsSafe(
-  node: t.SwitchStatement,
-  scope: Scope,
-  referencePath: NodePath,
-): boolean {
+function labeledLoweringIsSafe(node: t.SwitchStatement, scope: Scope): boolean {
   const defaultIndex = node.cases.findIndex((caseClause) => caseClause.test === null)
   if (defaultIndex === -1 || defaultIndex === node.cases.length - 1) {
     return true
   }
-  return node.cases.every(
-    (caseClause) => caseClause.test == null || isPure(caseClause.test, scope, referencePath),
-  )
+  return node.cases.every((caseClause) => caseClause.test == null || isPure(caseClause.test, scope))
 }
 
 function canLowerToIfElseChain(node: t.SwitchStatement): boolean {

package/src/transforms/ternary-to-if.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'
 import { isConditionalGate, reorderableToStatement } from '../utils/evaluation-order'
@@ -35,7 +34,7 @@ export function ternaryToIf(ast: File): boolean {
 
 const preparationVisitor: Visitor<ChangeState> = {
   ConditionalExpression(path, state) {
-    if (!isPathLive(path) || isInsideWith(path)) {
+    if (!isPathLive(path)) {
       return
     }
     const stmtPath = path.getStatementParent()
@@ -50,9 +49,8 @@ const preparationVisitor: Visitor<ChangeState> = {
 
 const visitor: Visitor<ChangeState> = {
   ConditionalExpression(path, state) {
-    // Statement replacement detaches queued siblings. `with` can also shadow the
-    // synthesized result temporary.
-    if (!isPathLive(path) || isInsideWith(path)) {
+    // Statement replacement detaches queued siblings.
+    if (!isPathLive(path)) {
       return
     }
     if (lowerConditional(path)) {
@@ -129,16 +127,14 @@ function lowerConditional(path: NodePath<t.ConditionalExpression>): boolean {
     t.isIdentifier(parent.node.id) &&
     parent.node.init === path.node &&
     parent.parentPath?.isVariableDeclaration() &&
-    // Splitting lexical declarations would end TDZ early, and bare `const` is
-    // invalid. Keep their initializer behind a result temp.
-    parent.parentPath.node.kind === 'var' &&
     parent.parentPath.node.declarations.length === 1 &&
     isStandaloneDeclaration(parent.parentPath)
   ) {
     const declPath = parent.parentPath
     const target = parent.node.id
+    const declarationKind = declPath.node.kind === 'const' ? 'let' : declPath.node.kind
     declPath.replaceWithMultiple([
-      t.variableDeclaration(declPath.node.kind, [t.variableDeclarator(t.cloneNode(target))]),
+      t.variableDeclaration(declarationKind, [t.variableDeclarator(t.cloneNode(target))]),
       t.ifStatement(
         test,
         t.blockStatement(seqWithAssignment(consequent, target)),

package/src/transforms/update-to-assignment.ts

@@ -2,7 +2,6 @@ import type { Binding, 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'
 
@@ -44,10 +43,6 @@ const visitor: Visitor<ChangeState> = {
     if (!prefix && !valueIsDiscarded(path)) {
       return
     }
-    // `with` can retarget the name and defeat the numeric proof.
-    if (isInsideWith(path)) {
-      return
-    }
     const binding = path.scope.getBinding(argument.name)
     if (!isNumericBinding(binding)) {
       return
@@ -75,19 +70,22 @@ function valueIsDiscarded(path: NodePath<t.UpdateExpression>): boolean {
   return false
 }
 
-// The initializer and every mutation must keep the binding numeric.
+// Mutable bindings must stay numeric. A const write cannot change its value.
 function isNumericBinding(binding: Binding | undefined): boolean {
-  if (!binding || (binding.kind !== 'var' && binding.kind !== 'let')) {
+  if (!binding || (binding.kind !== 'var' && binding.kind !== 'let' && binding.kind !== 'const')) {
     return false
   }
   const declarator = binding.path.node
   if (!t.isVariableDeclarator(declarator) || !t.isNumericLiteral(declarator.init)) {
     return false
   }
-  // Babel misses the string writes from an Annex B `for-in` initializer.
+  // Babel does not record each value assigned by a `for-in` or `for-of` head.
   if (isForInOfLoopVariable(binding)) {
     return false
   }
+  if (binding.kind === 'const') {
+    return true
+  }
   return binding.constantViolations.every((violation) => keepsNumeric(violation.node))
 }