webfuscator 1.1.0 → 1.2.1

package/src/transforms/pack.ts

@@ -4,11 +4,108 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import type { TransformContext } from 'src/options'
-import { isInsideWith } from 'src/utils/ast'
-import { isCalleeOrTagOf, isInStrictContext, referencesOrWritesVariable } from 'src/utils/paths'
-import { mulberry32 } from 'src/utils/random'
-import { StringGenerator } from 'src/utils/string-generator'
+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'
+
+// The ECMAScript intrinsics and the common host globals. A detached Function
+// body reaches every one of them and gets the same value, so pack can leave them
+// bare. The CommonJS wrapper names (require, module, exports, __dirname,
+// __filename) are left out on purpose. They are function parameters, not
+// properties of the global object, so a Function body cannot see them and pack
+// routes them like any other free name. `skipGlobals: true` opts into this list.
+const STANDARD_GLOBALS: readonly string[] = [
+  'globalThis',
+  'self',
+  'Infinity',
+  'NaN',
+  'undefined',
+  'parseInt',
+  'parseFloat',
+  'isNaN',
+  'isFinite',
+  'decodeURI',
+  'decodeURIComponent',
+  'encodeURI',
+  'encodeURIComponent',
+  'escape',
+  'unescape',
+  'btoa',
+  'atob',
+  'structuredClone',
+  'fetch',
+  'queueMicrotask',
+  'setTimeout',
+  'clearTimeout',
+  'setInterval',
+  'clearInterval',
+  'setImmediate',
+  'clearImmediate',
+  'Object',
+  'Function',
+  'Boolean',
+  'Symbol',
+  'BigInt',
+  'Number',
+  'Math',
+  'Date',
+  'String',
+  'RegExp',
+  'JSON',
+  'Promise',
+  'Proxy',
+  'Reflect',
+  'Error',
+  'EvalError',
+  'RangeError',
+  'ReferenceError',
+  'SyntaxError',
+  'TypeError',
+  'URIError',
+  'AggregateError',
+  'Array',
+  'Map',
+  'Set',
+  'WeakMap',
+  'WeakSet',
+  'WeakRef',
+  'FinalizationRegistry',
+  'ArrayBuffer',
+  'SharedArrayBuffer',
+  'DataView',
+  'Atomics',
+  'Int8Array',
+  'Uint8Array',
+  'Uint8ClampedArray',
+  'Int16Array',
+  'Uint16Array',
+  'Int32Array',
+  'Uint32Array',
+  'Float32Array',
+  'Float64Array',
+  'BigInt64Array',
+  'BigUint64Array',
+  'console',
+  'crypto',
+  'performance',
+  'Intl',
+  'URL',
+  'URLSearchParams',
+  'TextEncoder',
+  'TextDecoder',
+  'WebAssembly',
+  'window',
+  'document',
+  'location',
+  'postMessage',
+  'alert',
+  'confirm',
+  'global',
+  'process',
+  'Buffer',
+]
 
 /**
  * Serializes the whole program to a string and rebuilds it at runtime through
@@ -94,14 +191,19 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
   const readProperties = new Map<string, string>()
   const typeofProperties = new Map<string, string>()
   const settable = new Set<string>()
+  const freshProperty = (): string => {
+    let property: string
+    do {
+      // `__proto__` as an object-literal key would set the prototype rather
+      // than name an accessor.
+      property = generator.next()
+    } while (property === '__proto__')
+    return property
+  }
   const propertyFor = (registry: Map<string, string>, name: string): string => {
     let property = registry.get(name)
     if (property === undefined) {
-      do {
-        // `__proto__` as an object-literal key would set the prototype rather
-        // than name an accessor.
-        property = generator.next()
-      } while (property === '__proto__')
+      property = freshProperty()
       registry.set(name, property)
     }
     return property
@@ -109,8 +211,25 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
   const memberFor = (property: string): t.MemberExpression =>
     t.memberExpression(t.identifier(objectName), t.stringLiteral(property), true)
 
+  // Import locals read as free once detached but are unreachable from a Function
+  // body, so they route even when the caller lists them in skipGlobals.
+  const importedNames = new Set<string>()
+  for (const declaration of importDeclarations) {
+    for (const specifier of declaration.specifiers) {
+      importedNames.add(specifier.local.name)
+    }
+  }
+  const skipOption = ctx.pack?.skipGlobals ?? false
+  let skipNames: readonly string[] = []
+  if (skipOption === true) {
+    skipNames = STANDARD_GLOBALS
+  } else if (skipOption !== false) {
+    skipNames = skipOption
+  }
+  const skip = new Set<string>(skipNames)
+
   const isRoutable = (path: NodePath<t.Identifier>): boolean => {
-    const { name } = path.node
+    const name = path.node.name
     // The wrapper parameter stays as written. `arguments` and `eval` are never
     // routed: `arguments` binds to its own function's object, and leaving `eval`
     // bare keeps a direct eval reading the body scope rather than the global one.
@@ -125,10 +244,28 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
     if (!referencesOrWritesVariable(path)) {
       return false
     }
-    return !path.scope.getBinding(name)
+    if (path.scope.getBinding(name)) {
+      return false
+    }
+    return importedNames.has(name) || !skip.has(name)
   }
 
+  // A strict script's top-level `this` is the global object, but a strict
+  // Function called plainly sees `undefined`. Rather than reach for `.call`,
+  // route top-level `this` through a captured property like any free name.
+  const routeTopLevelThis = bodyStrict && !wasModule
+  let thisProperty: string | null = null
+
   const routingVisitor: Visitor = {
+    ThisExpression(path) {
+      if (!routeTopLevelThis || !isTopLevelThis(path)) {
+        return
+      }
+      if (thisProperty === null) {
+        thisProperty = freshProperty()
+      }
+      path.replaceWith(memberFor(thisProperty))
+    },
     UnaryExpression(path) {
       if (path.node.operator !== 'typeof') {
         return
@@ -147,7 +284,7 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
       if (isBareDeleteArgument(path) || !isRoutable(path)) {
         return
       }
-      const { name } = path.node
+      const name = path.node.name
       if (isWriteReference(path)) {
         settable.add(name)
       }
@@ -163,7 +300,7 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
 
   // The script completion value is its trailing expression; returning it keeps
   // `eval` of the packed output producing the same value.
-  const { body } = programNode
+  const body = programNode.body
   const lastStatement = body.at(-1)
   if (lastStatement && t.isExpressionStatement(lastStatement)) {
     body[body.length - 1] = t.returnStatement(lastStatement.expression)
@@ -181,6 +318,7 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
     settable,
     setterParam,
     strict: bodyStrict,
+    thisProperty,
   })
 
   const constructorReference = shadowedConstructor
@@ -193,16 +331,7 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
     t.stringLiteral(objectName),
     t.stringLiteral(innerCode),
   ])
-  // A strict script keeps top-level `this` bound to the global object. A plainly
-  // called strict function would instead see `undefined`, so pass the global
-  // `this` of the sloppy output script.
-  const invocation =
-    bodyStrict && !wasModule
-      ? t.callExpression(t.memberExpression(wrapper, t.identifier('call')), [
-          t.thisExpression(),
-          objectExpression,
-        ])
-      : t.callExpression(wrapper, [objectExpression])
+  const invocation = t.callExpression(wrapper, [objectExpression])
 
   programNode.body = [...importDeclarations, t.expressionStatement(invocation)]
   programNode.directives = []
@@ -238,6 +367,45 @@ function bindsFunctionConstructor(declaration: t.ImportDeclaration): boolean {
   return declaration.specifiers.some((specifier) => specifier.local.name === 'Function')
 }
 
+// A `this` refers to the top-level `this` when no enclosing non-arrow function,
+// class field, or static block captures it before the program does. A computed
+// member key is the exception: it evaluates in the scope surrounding its method
+// or field, not that member's `this`, so a `this` reached through a boundary's
+// `key` skips it and keeps looking outward. `thisBinding` keeps every path
+// predicate off the walked `current`, whose narrowed union would otherwise trip
+// NodePath's invariant generic when reassigned to `child`.
+function isTopLevelThis(path: NodePath<t.ThisExpression>): boolean {
+  let child: NodePath = path
+  let current: NodePath | null = path.parentPath
+  while (current) {
+    const binding = thisBinding(current)
+    if (binding === 'program') {
+      return true
+    }
+    if (binding === 'captured' && child.key !== 'key') {
+      return false
+    }
+    child = current
+    current = current.parentPath
+  }
+  return false
+}
+
+function thisBinding(boundary: NodePath): 'captured' | 'program' | null {
+  if (boundary.isProgram()) {
+    return 'program'
+  }
+  if (
+    (boundary.isFunction() && !boundary.isArrowFunctionExpression()) ||
+    boundary.isClassProperty() ||
+    boundary.isClassPrivateProperty() ||
+    boundary.isStaticBlock()
+  ) {
+    return 'captured'
+  }
+  return null
+}
+
 function isBareDeleteArgument(path: NodePath<t.Identifier>): boolean {
   const parent = path.parentPath
   return (
@@ -252,7 +420,7 @@ function isWriteReference(path: NodePath<t.Identifier>): boolean {
   if (!parent) {
     return false
   }
-  const { node } = path
+  const node = path.node
   if (parent.isAssignmentExpression() && parent.node.left === node) {
     return true
   }
@@ -291,13 +459,13 @@ interface AccessorObjectSpec {
   setterParam: string
   settable: Set<string>
   strict: boolean
+  thisProperty: string | null
   typeofProperties: Map<string, string>
 }
 
 function buildAccessorObject(spec: AccessorObjectSpec): t.ObjectExpression {
-  const { readProperties, setterParam, settable, strict, typeofProperties } = spec
-  const properties: t.ObjectMethod[] = []
-  for (const [name, property] of readProperties) {
+  const properties: (t.ObjectMethod | t.ObjectProperty)[] = []
+  for (const [name, property] of spec.readProperties) {
     properties.push(
       t.objectMethod(
         'get',
@@ -306,23 +474,28 @@ function buildAccessorObject(spec: AccessorObjectSpec): t.ObjectExpression {
         t.blockStatement([t.returnStatement(t.identifier(name))]),
       ),
     )
-    if (settable.has(name)) {
+    if (spec.settable.has(name)) {
       const setterBody = t.blockStatement([
         t.expressionStatement(
-          t.assignmentExpression('=', t.identifier(name), t.identifier(setterParam)),
+          t.assignmentExpression('=', t.identifier(name), t.identifier(spec.setterParam)),
         ),
       ])
       // A strict script becomes a sloppy output script, so the setter stays
       // strict to keep an undeclared-global write throwing.
-      if (strict) {
+      if (spec.strict) {
         setterBody.directives.push(t.directive(t.directiveLiteral('use strict')))
       }
       properties.push(
-        t.objectMethod('set', t.stringLiteral(property), [t.identifier(setterParam)], setterBody),
+        t.objectMethod(
+          'set',
+          t.stringLiteral(property),
+          [t.identifier(spec.setterParam)],
+          setterBody,
+        ),
       )
     }
   }
-  for (const [name, property] of typeofProperties) {
+  for (const [name, property] of spec.typeofProperties) {
     properties.push(
       t.objectMethod(
         'get',
@@ -332,5 +505,11 @@ function buildAccessorObject(spec: AccessorObjectSpec): t.ObjectExpression {
       ),
     )
   }
+  // This is a data property. Its `this` value evaluates in the output script's
+  // top-level scope, where `this` is the global object. A getter would bind
+  // `this` to the accessor object instead.
+  if (spec.thisProperty !== null) {
+    properties.push(t.objectProperty(t.stringLiteral(spec.thisProperty), t.thisExpression()))
+  }
   return t.objectExpression(properties)
 }

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

@@ -2,8 +2,8 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
+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
@@ -25,7 +25,7 @@ export function removeAnonymousFunctionNames(ast: File): boolean {
 
 const visitor: Visitor<ChangeState> = {
   FunctionExpression(path, state) {
-    const { id } = path.node
+    const id = path.node.id
     if (!id) {
       return
     }
@@ -48,8 +48,8 @@ const visitor: Visitor<ChangeState> = {
 
 // No inferred name means `.name` would become empty.
 function inferredName(path: NodePath<t.FunctionExpression>): string | null {
-  const { node } = path
-  const { parentPath } = path
+  const node = path.node
+  const parentPath = path.parentPath
   if (!parentPath) {
     return null
   }

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

@@ -2,8 +2,8 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
 
 /**
  * Removes statements after unconditional control flow in the same statement list.
@@ -72,7 +72,7 @@ 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
+  const node = path.node
   if (t.isFunctionDeclaration(node) || (t.isVariableDeclaration(node) && node.kind === 'var')) {
     return false
   }

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

@@ -3,10 +3,10 @@ import type { NodePath, Scope, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isSideEffectFree } from 'src/analysis/purity'
-import { isDirectEvalCall } from 'src/utils/ast'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { hasAnnexBFunctionAlias } from 'src/utils/paths'
+import { isSideEffectFree } from '../analysis/purity'
+import { isDirectEvalCall } from '../utils/ast'
+import type { ChangeState } from '../utils/change-tracking'
+import { hasAnnexBFunctionAlias } from '../utils/paths'
 
 /**
  * Removes unused declarations and expression statements that have no effects.
@@ -150,12 +150,12 @@ function tryRemoveDeclarator(
     return false
   }
 
-  const { id } = path.node
+  const id = path.node.id
   if (!t.isIdentifier(id)) {
     return false
   }
 
-  const { init } = path.node
+  const init = path.node.init
   if (init && !isSideEffectFree(init, path.scope, path.get('init') as NodePath)) {
     return false
   }
@@ -196,7 +196,7 @@ function tryRemoveFunctionDecl(
   if (hasAnnexBFunctionAlias(path)) {
     return false
   }
-  const { id } = path.node
+  const id = path.node.id
   if (!id) {
     return false
   }
@@ -228,7 +228,7 @@ function tryRemoveClassDecl(
   if (isExported(path)) {
     return false
   }
-  const { id } = path.node
+  const id = path.node.id
   if (!id) {
     return false
   }

package/src/transforms/rename-identifiers.ts

@@ -3,11 +3,11 @@ import type { Binding, Scope } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import type { TransformContext } from 'src/options'
-import { isDirectEvalCall, isInsideWith } from 'src/utils/ast'
-import { hasAnnexBFunctionAlias, referencesOrWritesVariable } from 'src/utils/paths'
-import { mulberry32 } from 'src/utils/random'
-import { StringGenerator } from 'src/utils/string-generator'
+import type { TransformContext } from '../options'
+import { isDirectEvalCall, isInsideWith } from '../utils/ast'
+import { hasAnnexBFunctionAlias, 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
@@ -125,7 +125,7 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
 
   traverse(ast, {
     Scopable(path) {
-      const { scope } = path
+      const scope = path.scope
       // Test global reservations during allocation to avoid copying them per scope.
       const offLimits = new Set<string>()
       const live = liveAncestors.get(scope)
@@ -174,7 +174,7 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
 
   traverse(ast, {
     Identifier(path) {
-      const { node } = path
+      const node = path.node
       const directName = idToName.get(node)
       if (directName !== undefined) {
         node.name = directName
@@ -200,7 +200,8 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
 }
 
 function isNonBindingPosition(path: { node: t.Identifier; parent: t.Node }): boolean {
-  const { node, parent } = path
+  const node = path.node
+  const parent = path.parent
   // A PrivateName id is not a variable and must match its class declaration.
   if (t.isPrivateName(parent)) {
     return true

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

@@ -3,11 +3,11 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import type { TransformContext } from 'src/options'
-import { enclosingScopeHasDirectEval, isInsideWith } from 'src/utils/ast'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { mulberry32 } from 'src/utils/random'
-import { StringGenerator } from 'src/utils/string-generator'
+import type { TransformContext } from '../options'
+import { enclosingScopeHasDirectEval, isInsideWith } from '../utils/ast'
+import type { ChangeState } from '../utils/change-tracking'
+import { mulberry32 } from '../utils/random'
+import { StringGenerator } from '../utils/string-generator'
 
 /**
  * Rewrites five constant-like values through strings for later string mangling:
@@ -59,7 +59,7 @@ const visitor: Visitor<State> = {
     state.changed = true
   },
   Identifier(path, state) {
-    const { name } = path.node
+    const name = path.node.name
     if (!GLOBAL_SPECIALS.has(name)) {
       return
     }
@@ -93,7 +93,7 @@ function buildGlobalReplacement(name: string, str: t.StringLiteral): t.Expressio
 // Babel calls update and iterator targets references, but replacements there
 // would not be assignable. Delete also distinguishes references from values.
 function isWriteTarget(path: NodePath<t.Identifier>): boolean {
-  const { parentPath } = path
+  const parentPath = path.parentPath
   if (!parentPath) {
     return false
   }

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

@@ -2,11 +2,11 @@ import type { NodePath, Scope, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isPure } from 'src/analysis/purity'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { isPrimitiveLiteral } from 'src/utils/literal'
-import { generateLoopLabel } from 'src/utils/loop-lowering'
+import { isPure } from '../analysis/purity'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
+import { isPrimitiveLiteral } from '../utils/literal'
+import { generateLoopLabel } from '../utils/loop-lowering'
 
 /**
  * Lowers `switch` to an `if` chain or, when cases fall through, a labeled block
@@ -46,7 +46,7 @@ const visitor: Visitor<ChangeState> = {
 }
 
 function transformSwitch(path: NodePath<t.SwitchStatement>): boolean {
-  const { node } = path
+  const node = path.node
   // Separate `if` blocks cannot preserve cross-case lexical scope or Annex B
   // function hoisting.
   if (hasBlockScopedDeclaration(node)) {
@@ -114,7 +114,7 @@ function canLowerToIfElseChain(node: t.SwitchStatement): boolean {
 }
 
 function caseEligibleForIfElseChain(caseClause: t.SwitchCase, isLast: boolean): boolean {
-  const { consequent } = caseClause
+  const consequent = caseClause.consequent
   if (consequent.length === 0) {
     return isLast
   }
@@ -189,8 +189,8 @@ function buildBody(consequent: t.Statement[]): t.BlockStatement {
 }
 
 function lowerToIfElseChain(path: NodePath<t.SwitchStatement>): void {
-  const { node } = path
-  const { scope } = path
+  const node = path.node
+  const scope = path.scope
 
   let discriminantExpr: t.Expression
   const preStmts: t.Statement[] = []
@@ -244,8 +244,8 @@ function lowerToIfElseChain(path: NodePath<t.SwitchStatement>): void {
 }
 
 function lowerToLabeledBlock(path: NodePath<t.SwitchStatement>): void {
-  const { node } = path
-  const { scope } = path
+  const node = path.node
+  const scope = path.scope
 
   // `scope.generateUid` alone can collide with enclosing or nested labels.
   const labelName = generateLoopLabel(path, 'switch')
@@ -314,7 +314,7 @@ function lowerToLabeledBlock(path: NodePath<t.SwitchStatement>): void {
 
   const labeledBlock = t.labeledStatement(t.identifier(labelName), t.blockStatement(statements))
 
-  const [labeledPath] = path.replaceWith(labeledBlock)
+  const labeledPath = path.replaceWith(labeledBlock)[0]
   rewriteUnlabeledBreaks(labeledPath, labelName)
 }
 

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

@@ -2,11 +2,11 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isInsideWith } from 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { isConditionalGate, reorderableToStatement } from 'src/utils/evaluation-order'
-import { isStandaloneDeclaration } from 'src/utils/paths'
+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'
+import { isStandaloneDeclaration } from '../utils/paths'
 
 /**
  * Lowers conditional expressions to `if` statements. Expression values use a
@@ -67,7 +67,9 @@ function lowerConditional(path: NodePath<t.ConditionalExpression>): boolean {
     return false
   }
 
-  const { test, consequent, alternate } = path.node
+  const test = path.node.test
+  const consequent = path.node.consequent
+  const alternate = path.node.alternate
 
   if (parent.isExpressionStatement() && parent.node.expression === path.node) {
     parent.replaceWith(
@@ -163,7 +165,7 @@ function lowerConditional(path: NodePath<t.ConditionalExpression>): boolean {
     return false
   }
 
-  const { scope } = path
+  const scope = path.scope
   const tmpId = scope.generateUidIdentifier('ternaryResult')
   scope.push({ id: t.cloneNode(tmpId) })
 
@@ -293,8 +295,9 @@ function lowerEnclosingLogical(path: NodePath, stmtPath: NodePath): boolean {
   if (!logical || logical.removed || !logical.container) {
     return false
   }
-  const { node } = logical
-  const { left, right } = node
+  const node = logical.node
+  const left = node.left
+  const right = node.right
   let test: t.Expression
   let valueRef: t.Expression
   if (t.isIdentifier(left) && logical.scope.hasBinding(left.name)) {

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

@@ -2,9 +2,9 @@ import type { Binding, NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isDirectEvalCall, isInsideWith } from 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
+import { isDirectEvalCall, isInsideWith } from '../utils/ast'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
 
 /**
  * Rewrites numeric updates as compound assignments for later expansion. Prefix
@@ -35,7 +35,9 @@ export function updateToAssignment(ast: File): boolean {
 
 const visitor: Visitor<ChangeState> = {
   UpdateExpression(path, state) {
-    const { argument, prefix, operator } = path.node
+    const argument = path.node.argument
+    const prefix = path.node.prefix
+    const operator = path.node.operator
     if (!t.isIdentifier(argument)) {
       return
     }
@@ -61,7 +63,7 @@ const visitor: Visitor<ChangeState> = {
 }
 
 function valueIsDiscarded(path: NodePath<t.UpdateExpression>): boolean {
-  const { parentPath } = path
+  const parentPath = path.parentPath
   if (!parentPath) {
     return false
   }