webfuscator 1.0.1 → 1.2.0

package/src/transforms/pack.ts

@@ -0,0 +1,340 @@
+import generate from '@babel/generator'
+import traverse from '@babel/traverse'
+import type { NodePath, Visitor } from '@babel/traverse'
+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'
+
+/**
+ * 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. Import declarations return above the call. `eval`
+ * is left un-routed so a direct eval still reads the body scope. Names inside a
+ * `with` stay un-routed too, since they may resolve against the with object at
+ * runtime. Export statements cannot live inside a Function body, so pack throws
+ * on them. It packs everything else as written. Code that needs `import.meta`,
+ * top-level await, dynamic `import()`, or a top-level `arguments` will not run
+ * once moved into a Function body.
+ *
+ * @example
+ * // ◀️ before
+ * console.log(value);
+ *
+ * // ▶️ after
+ * Function("M", "return M[\"b\"].log(M[\"_\"]);")({
+ *   get "b"() {
+ *     return console;
+ *   },
+ *   get "_"() {
+ *     return value;
+ *   }
+ * });
+ */
+export function pack(ast: File, ctx: TransformContext): boolean {
+  let programPath: NodePath<t.Program> | null = null
+  traverse(ast, {
+    Program(path) {
+      programPath = path
+      path.stop()
+    },
+  })
+  if (!programPath) {
+    return false
+  }
+  return packProgram(programPath, ctx)
+}
+
+function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): boolean {
+  assertNoExports(programPath)
+  const importPaths = collectImportDeclarations(programPath)
+  const importDeclarations = importPaths.map((path) => path.node)
+  // An import named `Function` shadows the constructor at the output top level,
+  // so the wrap reaches the real one through a function instance instead.
+  const shadowedConstructor = importDeclarations.some((declaration) =>
+    bindsFunctionConstructor(declaration),
+  )
+
+  const programNode = programPath.node
+  const wasModule = programNode.sourceType === 'module'
+  // Escaping strict is a deliberate opt-in: drop the directive so the packed
+  // body runs sloppy even when the source was strict.
+  const escapeStrict = ctx.pack?.escapeStrict ?? false
+  const bodyStrict = !escapeStrict && isInStrictContext(programPath)
+
+  // Detaching imports drops their bindings, so their names read as free and are
+  // routed like any other global. The declarations return at the output top
+  // level, where the accessors close over them.
+  for (const path of importPaths) {
+    path.remove()
+  }
+  programPath.scope.crawl()
+
+  const usedNames = collectUsedNames(programNode, importDeclarations)
+  const generator = new StringGenerator(ctx.stringGeneratorMode, mulberry32(ctx.seed))
+  const freshIdentifier = (): string => {
+    let name: string
+    do {
+      name = generator.next()
+    } while (usedNames.has(name))
+    usedNames.add(name)
+    return name
+  }
+  const objectName = freshIdentifier()
+  const setterParam = freshIdentifier()
+
+  const readProperties = new Map<string, string>()
+  const typeofProperties = new Map<string, string>()
+  const settable = new Set<string>()
+  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__')
+      registry.set(name, property)
+    }
+    return property
+  }
+  const memberFor = (property: string): t.MemberExpression =>
+    t.memberExpression(t.identifier(objectName), t.stringLiteral(property), true)
+
+  const isRoutable = (path: NodePath<t.Identifier>): boolean => {
+    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.
+    if (name === objectName || name === 'arguments' || name === 'eval') {
+      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
+    }
+    return !path.scope.getBinding(name)
+  }
+
+  const routingVisitor: Visitor = {
+    UnaryExpression(path) {
+      if (path.node.operator !== 'typeof') {
+        return
+      }
+      const argument = path.get('argument')
+      // A bare `typeof name` must not throw for an undeclared global, so it maps
+      // to an accessor that applies `typeof` in the original scope.
+      if (!argument.isIdentifier() || !isRoutable(argument)) {
+        return
+      }
+      path.replaceWith(memberFor(propertyFor(typeofProperties, argument.node.name)))
+    },
+    Identifier(path) {
+      // `delete name` must keep hitting the global binding; `delete obj[prop]`
+      // would drop the accessor instead. A real global stays reachable bare.
+      if (isBareDeleteArgument(path) || !isRoutable(path)) {
+        return
+      }
+      const name = path.node.name
+      if (isWriteReference(path)) {
+        settable.add(name)
+      }
+      const member = memberFor(propertyFor(readProperties, name))
+      // A member callee would bind `this` to the object; the comma discards the
+      // base and keeps the original receiver.
+      path.replaceWith(
+        isCalleeOrTagOf(path) ? t.sequenceExpression([t.numericLiteral(0), member]) : member,
+      )
+    },
+  }
+  programPath.traverse(routingVisitor)
+
+  // The script completion value is its trailing expression; returning it keeps
+  // `eval` of the packed output producing the same value.
+  const body = programNode.body
+  const lastStatement = body.at(-1)
+  if (lastStatement && t.isExpressionStatement(lastStatement)) {
+    body[body.length - 1] = t.returnStatement(lastStatement.expression)
+  }
+
+  const innerDirectives = bodyStrict ? [t.directive(t.directiveLiteral('use strict'))] : []
+  const innerCode = generate(t.program(body, innerDirectives, 'script'), {
+    minified: true,
+    comments: false,
+  }).code
+
+  const objectExpression = buildAccessorObject({
+    readProperties,
+    typeofProperties,
+    settable,
+    setterParam,
+    strict: bodyStrict,
+  })
+
+  const constructorReference = shadowedConstructor
+    ? t.memberExpression(
+        t.functionExpression(null, [], t.blockStatement([])),
+        t.identifier('constructor'),
+      )
+    : t.identifier('Function')
+  const wrapper = t.callExpression(constructorReference, [
+    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])
+
+  programNode.body = [...importDeclarations, t.expressionStatement(invocation)]
+  programNode.directives = []
+  programNode.sourceType = importDeclarations.length > 0 ? 'module' : 'script'
+  return true
+}
+
+// Export statements are module-only syntax and cannot exist inside a Function
+// body. Pack throws rather than emit output that fails to parse at runtime.
+function assertNoExports(programPath: NodePath<t.Program>): void {
+  const hasExport = programPath.node.body.some(
+    (statement) =>
+      t.isExportNamedDeclaration(statement) ||
+      t.isExportDefaultDeclaration(statement) ||
+      t.isExportAllDeclaration(statement),
+  )
+  if (hasExport) {
+    throw new Error('pack cannot wrap a program that uses export statements')
+  }
+}
+
+function collectImportDeclarations(
+  programPath: NodePath<t.Program>,
+): NodePath<t.ImportDeclaration>[] {
+  return programPath
+    .get('body')
+    .filter((statement): statement is NodePath<t.ImportDeclaration> =>
+      statement.isImportDeclaration(),
+    )
+}
+
+function bindsFunctionConstructor(declaration: t.ImportDeclaration): boolean {
+  return declaration.specifiers.some((specifier) => specifier.local.name === 'Function')
+}
+
+function isBareDeleteArgument(path: NodePath<t.Identifier>): boolean {
+  const parent = path.parentPath
+  return (
+    parent != null &&
+    parent.isUnaryExpression({ operator: 'delete' }) &&
+    parent.node.argument === path.node
+  )
+}
+
+function isWriteReference(path: NodePath<t.Identifier>): boolean {
+  const parent = path.parentPath
+  if (!parent) {
+    return false
+  }
+  const node = path.node
+  if (parent.isAssignmentExpression() && parent.node.left === node) {
+    return true
+  }
+  if (parent.isUpdateExpression() && parent.node.argument === node) {
+    return true
+  }
+  if ((parent.isForInStatement() || parent.isForOfStatement()) && parent.node.left === node) {
+    return true
+  }
+  // Destructuring assignment targets bind through patterns Babel flags here.
+  return path.isBindingIdentifier()
+}
+
+function collectUsedNames(
+  program: t.Program,
+  importDeclarations: t.ImportDeclaration[],
+): Set<string> {
+  // The wrapper parameter and setter parameter must avoid every name the body
+  // uses, so no nested binding can shadow their accesses.
+  const names = new Set<string>(['Function'])
+  for (const declaration of importDeclarations) {
+    for (const specifier of declaration.specifiers) {
+      names.add(specifier.local.name)
+    }
+  }
+  t.traverseFast(program, (node) => {
+    if (t.isIdentifier(node)) {
+      names.add(node.name)
+    }
+  })
+  return names
+}
+
+interface AccessorObjectSpec {
+  readProperties: Map<string, string>
+  setterParam: string
+  settable: Set<string>
+  strict: boolean
+  typeofProperties: Map<string, string>
+}
+
+function buildAccessorObject(spec: AccessorObjectSpec): t.ObjectExpression {
+  const properties: t.ObjectMethod[] = []
+  for (const [name, property] of spec.readProperties) {
+    properties.push(
+      t.objectMethod(
+        'get',
+        t.stringLiteral(property),
+        [],
+        t.blockStatement([t.returnStatement(t.identifier(name))]),
+      ),
+    )
+    if (spec.settable.has(name)) {
+      const setterBody = t.blockStatement([
+        t.expressionStatement(
+          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 (spec.strict) {
+        setterBody.directives.push(t.directive(t.directiveLiteral('use strict')))
+      }
+      properties.push(
+        t.objectMethod(
+          'set',
+          t.stringLiteral(property),
+          [t.identifier(spec.setterParam)],
+          setterBody,
+        ),
+      )
+    }
+  }
+  for (const [name, property] of spec.typeofProperties) {
+    properties.push(
+      t.objectMethod(
+        'get',
+        t.stringLiteral(property),
+        [],
+        t.blockStatement([t.returnStatement(t.unaryExpression('typeof', t.identifier(name)))]),
+      ),
+    )
+  }
+  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
   }