webfuscator 1.1.0 → 1.2.1

package/src/analysis/constant.ts

@@ -1,13 +1,13 @@
 import type { Binding, NodePath, Scope } from '@babel/traverse'
 import * as t from '@babel/types'
 
+import { enclosingScopeHasDirectEval, isInsideWith } from '../utils/ast'
 import {
   declarationReaches,
   initializerReaches,
   readCrossesFunctionBoundary,
-} from 'src/analysis/document-order'
-import { isSideEffectFree } from 'src/analysis/purity'
-import { enclosingScopeHasDirectEval, isInsideWith } from 'src/utils/ast'
+} from './document-order'
+import { isSideEffectFree } from './purity'
 
 export type Evaluation = { known: true; value: unknown } | { known: false }
 
@@ -48,7 +48,7 @@ const EVALUATORS: Partial<Record<t.Node['type'], Evaluator>> = {
     if (template.expressions.length > 0) {
       return UNKNOWN
     }
-    const [quasi] = template.quasis
+    const quasi = template.quasis[0]
     return { known: true, value: quasi?.value.cooked ?? quasi?.value.raw ?? '' }
   },
   UnaryExpression: evaluateUnary,

package/src/analysis/inlineability.ts

@@ -3,8 +3,7 @@ import type { Binding, NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { walkOwnFunctionScope } from 'src/utils/ast'
-import { hasAnnexBFunctionAlias, referencesOrWritesVariable } from 'src/utils/paths'
+import { hasAnnexBFunctionAlias, referencesOrWritesVariable } from '../utils/paths'
 
 export interface InlineCandidate {
   name: string
@@ -15,7 +14,10 @@ export interface InlineCandidate {
   declarationPath: NodePath
 }
 
-// Tarjan SCC removal prevents endless expansion of mutually recursive bodies.
+// Inlining splices a deep clone of the callee body, so any call that clone
+// contains expands again. Expansion stops only when the graph below is acyclic,
+// so this pass drops every candidate on a cycle before the inliner reaches a
+// call site.
 export function analyzeInlineability(ast: File): Map<string, InlineCandidate> {
   const rawCandidates: InlineCandidate[] = []
 
@@ -47,7 +49,7 @@ export function analyzeInlineability(ast: File): Map<string, InlineCandidate> {
       if (!t.isIdentifier(path.node.id)) {
         return
       }
-      const { init } = path.node
+      const init = path.node.init
       if (!t.isFunctionExpression(init)) {
         return
       }
@@ -75,34 +77,45 @@ export function analyzeInlineability(ast: File): Map<string, InlineCandidate> {
     candidateByName.set(candidate.name, candidate)
   }
 
-  // Self-reference is already excluded, leaving Tarjan to remove larger cycles.
+  const edges = buildExpansionGraph(candidateByName)
+  for (const scc of tarjanSCC([...candidateByName.keys()], edges)) {
+    // Tarjan reports an acyclic node as a singleton too, so a self-recursive
+    // candidate shows up only as an edge back to itself.
+    if (scc.length === 1 && !edges.get(scc[0]!)!.has(scc[0]!)) {
+      continue
+    }
+    for (const name of scc) {
+      candidateByName.delete(name)
+    }
+  }
+  return candidateByName
+}
+
+// A clone keeps the whole body, so a reference inside a closure, an object
+// method, or a getter is as live in the copy as one at the top level. Walking
+// out to every enclosing candidate, rather than stopping at the innermost, also
+// covers a candidate declared inside another candidate's body.
+function buildExpansionGraph(
+  candidateByName: Map<string, InlineCandidate>,
+): Map<string, Set<string>> {
+  const nameByFnNode = new Map<t.Function, string>()
   const edges = new Map<string, Set<string>>()
-  for (const candidate of rawCandidates) {
-    const callees = new Set<string>()
-    walkOwnFunctionScope(candidate.fnNode.body, (node) => {
-      if (t.isIdentifier(node) && node.name !== candidate.name && candidateByName.has(node.name)) {
-        callees.add(node.name)
-      }
-    })
-    edges.set(candidate.name, callees)
+  for (const [name, candidate] of candidateByName) {
+    nameByFnNode.set(candidate.fnNode, name)
+    edges.set(name, new Set())
   }
 
-  const inCycle = new Set<string>()
-  for (const scc of tarjanSCC(
-    rawCandidates.map((candidate) => candidate.name),
-    edges,
-  )) {
-    if (scc.length > 1) {
-      for (const name of scc) {
-        inCycle.add(name)
+  for (const [name, candidate] of candidateByName) {
+    for (const ref of candidate.binding.referencePaths) {
+      for (let owner = ref.parentPath; owner; owner = owner.parentPath) {
+        const ownerName = owner.isFunction() ? nameByFnNode.get(owner.node) : undefined
+        if (ownerName !== undefined) {
+          edges.get(ownerName)!.add(name)
+        }
       }
     }
   }
-
-  for (const name of inCycle) {
-    candidateByName.delete(name)
-  }
-  return candidateByName
+  return edges
 }
 
 function checkCandidate(
@@ -142,7 +155,7 @@ function checkCandidate(
     return null
   }
 
-  const analysis = analyzeBody(name, fnPath as NodePath<t.Function>)
+  const analysis = analyzeBody(fnPath as NodePath<t.Function>)
   if (analysis.unsafe || analysis.closureCapture) {
     return null
   }
@@ -200,9 +213,8 @@ interface BodyAnalysis {
   closureCapture: boolean
 }
 
-function analyzeBody(name: string, fnPath: NodePath<t.Function>): BodyAnalysis {
+function analyzeBody(fnPath: NodePath<t.Function>): BodyAnalysis {
   const state: AnalyzeBodyState = {
-    candidateName: name,
     outerScope: fnPath.scope,
     innerFnDepth: 0,
     unsafe: false,
@@ -216,7 +228,6 @@ function analyzeBody(name: string, fnPath: NodePath<t.Function>): BodyAnalysis {
 }
 
 interface AnalyzeBodyState {
-  candidateName: string
   outerScope: NodePath<t.Function>['scope']
   innerFnDepth: number
   unsafe: boolean
@@ -267,11 +278,8 @@ const analyzeBodyVisitor: Visitor<AnalyzeBodyState> = {
     path.stop()
   },
   Identifier(path, state) {
-    const { name } = path.node
-    if (
-      state.innerFnDepth === 0 &&
-      (name === 'arguments' || name === 'eval' || name === state.candidateName)
-    ) {
+    const name = path.node.name
+    if (state.innerFnDepth === 0 && (name === 'arguments' || name === 'eval')) {
       state.unsafe = true
       path.stop()
       return

package/src/analysis/purity.ts

@@ -1,13 +1,13 @@
 import type { Binding, NodePath, Scope } from '@babel/traverse'
 import * as t from '@babel/types'
 
+import { isInsideWith } from '../utils/ast'
+import { isPrimitiveLiteral } from '../utils/literal'
 import {
   declarationReaches,
   initializerReaches,
   readCrossesFunctionBoundary,
-} from 'src/analysis/document-order'
-import { isInsideWith } from 'src/utils/ast'
-import { isPrimitiveLiteral } from 'src/utils/literal'
+} from './document-order'
 
 // Purity also requires deterministic repetition and no throw. Identifier reads
 // need scope and reference paths to prove resolution, initialization, and the

package/src/index.ts

@@ -1,7 +1,9 @@
-export { obfuscate } from 'src/obfuscator'
+export { obfuscate } from './obfuscator'
 export type {
   ManglePropertiesOptions,
   ObfuscatorOptions,
   PackOptions,
   PropertyNameGenerator,
-} from 'src/options'
+  TransformName,
+} from './options'
+export type { StringGeneratorMode, StringGeneratorModeOption } from './utils/string-generator'

package/src/obfuscator.ts

@@ -3,48 +3,48 @@ import { parse } from '@babel/parser'
 import type { ParserOptions } from '@babel/parser'
 import type { File } from '@babel/types'
 
-import type { ObfuscatorOptions, TransformContext, TransformName } from 'src/options'
-import { dotToBracket } from 'src/preparation/dot-to-bracket'
-import { expandDestructuring } from 'src/preparation/expand-destructuring'
-import { expandTemplateLiterals } from 'src/preparation/expand-template-literals'
-import { splitSequenceExpressions } from 'src/preparation/split-sequence-expressions'
-import { splitVariableDeclarations } from 'src/preparation/split-variable-declarations'
-import { stringifyObjectKeys } from 'src/preparation/stringify-object-keys'
-import { wrapSingleStatements } from 'src/preparation/wrap-single-statements'
-import { argumentsToParameters } from 'src/transforms/arguments-to-parameters'
-import { arrowToFunction } from 'src/transforms/arrow-to-function'
-import { collapseSingleUseTemps } from 'src/transforms/collapse-single-use-temps'
-import { constLetToVar } from 'src/transforms/const-let-to-var'
-import { constToLet } from 'src/transforms/const-to-let'
-import { doWhileToWhile } from 'src/transforms/do-while-to-while'
-import { dropConsole } from 'src/transforms/drop-console'
-import { dropDebugger } from 'src/transforms/drop-debugger'
-import { expandBinaryAssignment } from 'src/transforms/expand-binary-assignment'
-import { expandLogicalAssignment } from 'src/transforms/expand-logical-assignment'
-import { extractObjectProperties } from 'src/transforms/extract-object-properties'
-import { foldBuiltinMethods } from 'src/transforms/fold-builtin-methods'
-import { foldConstants } from 'src/transforms/fold-constants'
-import { forToWhile } from 'src/transforms/for-to-while'
-import { functionDeclarationToExpression } from 'src/transforms/function-declaration-to-expression'
-import { inlineFunctions } from 'src/transforms/inline-functions'
-import { logicalToTernary } from 'src/transforms/logical-to-ternary'
-import { mangleProperties } from 'src/transforms/mangle-properties'
-import { nullishCoalescingToTernary } from 'src/transforms/nullish-coalescing-to-ternary'
-import { numbersToStrings } from 'src/transforms/numbers-to-strings'
-import { objectMethodToProperty } from 'src/transforms/object-method-to-property'
-import { optionalChainingToTernary } from 'src/transforms/optional-chaining-to-ternary'
-import { pack } from 'src/transforms/pack'
-import { packDeclarationsIntoParameters } from 'src/transforms/pack-declarations-into-parameters'
-import { removeAnonymousFunctionNames } from 'src/transforms/remove-anonymous-function-names'
-import { removeUnreachableCode } from 'src/transforms/remove-unreachable-code'
-import { removeUnusedCode } from 'src/transforms/remove-unused-code'
-import { renameIdentifiers } from 'src/transforms/rename-identifiers'
-import { specialsToStrings } from 'src/transforms/specials-to-strings'
-import { switchToIf } from 'src/transforms/switch-to-if'
-import { ternaryToIf } from 'src/transforms/ternary-to-if'
-import { updateToAssignment } from 'src/transforms/update-to-assignment'
-import { yodifyConditions } from 'src/transforms/yodify-conditions'
-import type { StringGeneratorModeOption } from 'src/utils/string-generator'
+import type { ObfuscatorOptions, TransformContext, TransformName } from './options'
+import { dotToBracket } from './preparation/dot-to-bracket'
+import { expandDestructuring } from './preparation/expand-destructuring'
+import { expandTemplateLiterals } from './preparation/expand-template-literals'
+import { splitSequenceExpressions } from './preparation/split-sequence-expressions'
+import { splitVariableDeclarations } from './preparation/split-variable-declarations'
+import { stringifyObjectKeys } from './preparation/stringify-object-keys'
+import { wrapSingleStatements } from './preparation/wrap-single-statements'
+import { argumentsToParameters } from './transforms/arguments-to-parameters'
+import { arrowToFunction } from './transforms/arrow-to-function'
+import { collapseSingleUseTemps } from './transforms/collapse-single-use-temps'
+import { constLetToVar } from './transforms/const-let-to-var'
+import { constToLet } from './transforms/const-to-let'
+import { doWhileToWhile } from './transforms/do-while-to-while'
+import { dropConsole } from './transforms/drop-console'
+import { dropDebugger } from './transforms/drop-debugger'
+import { expandBinaryAssignment } from './transforms/expand-binary-assignment'
+import { expandLogicalAssignment } from './transforms/expand-logical-assignment'
+import { extractObjectProperties } from './transforms/extract-object-properties'
+import { foldBuiltinMethods } from './transforms/fold-builtin-methods'
+import { foldConstants } from './transforms/fold-constants'
+import { forToWhile } from './transforms/for-to-while'
+import { functionDeclarationToExpression } from './transforms/function-declaration-to-expression'
+import { inlineFunctions } from './transforms/inline-functions'
+import { logicalToTernary } from './transforms/logical-to-ternary'
+import { mangleProperties } from './transforms/mangle-properties'
+import { nullishCoalescingToTernary } from './transforms/nullish-coalescing-to-ternary'
+import { numbersToStrings } from './transforms/numbers-to-strings'
+import { objectMethodToProperty } from './transforms/object-method-to-property'
+import { optionalChainingToTernary } from './transforms/optional-chaining-to-ternary'
+import { pack } from './transforms/pack'
+import { packDeclarationsIntoParameters } from './transforms/pack-declarations-into-parameters'
+import { removeAnonymousFunctionNames } from './transforms/remove-anonymous-function-names'
+import { removeUnreachableCode } from './transforms/remove-unreachable-code'
+import { removeUnusedCode } from './transforms/remove-unused-code'
+import { renameIdentifiers } from './transforms/rename-identifiers'
+import { specialsToStrings } from './transforms/specials-to-strings'
+import { switchToIf } from './transforms/switch-to-if'
+import { ternaryToIf } from './transforms/ternary-to-if'
+import { updateToAssignment } from './transforms/update-to-assignment'
+import { yodifyConditions } from './transforms/yodify-conditions'
+import type { StringGeneratorModeOption } from './utils/string-generator'
 
 const parserOptions: ParserOptions = { sourceType: 'unambiguous' }
 

package/src/options.ts

@@ -1,4 +1,4 @@
-import type { StringGeneratorModeOption } from 'src/utils/string-generator'
+import type { StringGeneratorModeOption } from './utils/string-generator'
 
 /**
  * Exported transform entry points. Preparation passes are always enabled and
@@ -84,6 +84,13 @@ export interface PackOptions {
    * source is strict. This deliberately changes behavior. Default `false`.
    */
   escapeStrict?: boolean
+  /**
+   * Free names to leave un-routed because they resolve to the real global from
+   * inside a detached Function body. `true` uses the built-in standard-globals
+   * list; an array names your own set. Stripped imports always route regardless,
+   * since a Function body cannot reach them. Default routes every free name.
+   */
+  skipGlobals?: boolean | readonly string[]
   /** Override the default string-generator mode for the names pack creates. */
   stringGeneratorMode?: StringGeneratorModeOption
 }

package/src/preparation/expand-destructuring.ts

@@ -3,7 +3,7 @@ import type { NodePath, Scope } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { enclosingScopeHasDirectEval, isInsideWith } from 'src/utils/ast'
+import { enclosingScopeHasDirectEval, isInsideWith } from '../utils/ast'
 
 type Kind = t.VariableDeclaration['kind']
 
@@ -47,12 +47,13 @@ const visitor = {
       return
     }
 
-    const { kind } = path.node
+    const kind = path.node.kind
     const replacement: t.Statement[] = []
     let changed = false
 
     for (const declarator of path.node.declarations) {
-      const { id, init } = declarator
+      const id = declarator.id
+      const init = declarator.init
 
       if (
         !init ||
@@ -135,7 +136,7 @@ function expandPattern(
       if (t.isRestElement(prop)) {
         continue
       }
-      const { key } = prop
+      const key = prop.key
       const useComputed = prop.computed || !t.isIdentifier(key)
       const access = t.memberExpression(
         t.cloneNode(src),

package/src/preparation/expand-template-literals.ts

@@ -3,7 +3,7 @@ import type { Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isInDirectivePrologue } from 'src/utils/ast'
+import { isInDirectivePrologue } from '../utils/ast'
 
 /**
  * Rewrites safe template literals as string concatenation. Tagged templates
@@ -31,12 +31,13 @@ export function expandTemplateLiterals(ast: File): void {
 
 const visitor: Visitor = {
   TemplateLiteral(path) {
-    const { parent } = path
+    const parent = path.parent
     if (t.isTaggedTemplateExpression(parent) && parent.quasi === path.node) {
       return
     }
 
-    const { quasis, expressions } = path.node
+    const quasis = path.node.quasis
+    const expressions = path.node.expressions
 
     if (expressions.length === 0) {
       // Rewriting a leading template as a string would create a directive.

package/src/preparation/split-sequence-expressions.ts

@@ -3,7 +3,7 @@ import type { NodePath } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isInDirectivePrologue } from 'src/utils/ast'
+import { isInDirectivePrologue } from '../utils/ast'
 
 /**
  * Splits comma-sequenced expression statements into one statement each.
@@ -30,7 +30,7 @@ const visitor = {
       return
     }
     // Splitting a leading string out of a sequence could create a directive.
-    const [first] = path.node.expression.expressions
+    const first = path.node.expression.expressions[0]
     if (t.isStringLiteral(first) && isInDirectivePrologue(path)) {
       return
     }

package/src/preparation/split-variable-declarations.ts

@@ -32,7 +32,7 @@ const visitor = {
     if (path.node.declarations.length <= 1) {
       return
     }
-    const { kind } = path.node
+    const kind = path.node.kind
     const replacements = path.node.declarations.map((decl) => t.variableDeclaration(kind, [decl]))
     path.replaceWithMultiple(replacements)
   },

package/src/preparation/stringify-object-keys.ts

@@ -3,7 +3,7 @@ import type { NodePath } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { isProtoKey } from 'src/utils/ast'
+import { isProtoKey } from '../utils/ast'
 
 /**
  * Rewrites property keys in object literals and classes as computed strings.
@@ -57,7 +57,7 @@ function keyOrderIsSpreadSensitive(path: NodePath<t.ObjectProperty | t.ObjectMet
   if (!object || !object.isObjectExpression()) {
     return false
   }
-  const { properties } = object.node
+  const properties = object.node.properties
   const hasSpread = properties.some((prop) => t.isSpreadElement(prop))
   if (!hasSpread) {
     return false

package/src/preparation/wrap-single-statements.ts

@@ -36,7 +36,7 @@ export function wrapSingleStatements(ast: File): void {
 
 const visitor = {
   IfStatement(path: { node: t.IfStatement }) {
-    const { node } = path
+    const node = path.node
     if (!t.isBlockStatement(node.consequent)) {
       node.consequent = t.blockStatement([node.consequent])
     }
@@ -48,7 +48,7 @@ const visitor = {
     wrapLoopBody(path.node)
   },
   ArrowFunctionExpression(path: { node: t.ArrowFunctionExpression }) {
-    const { node } = path
+    const node = path.node
     if (!t.isBlockStatement(node.body)) {
       node.body = t.blockStatement([t.returnStatement(node.body)])
       node.expression = false

package/src/transforms/arguments-to-parameters.ts

@@ -2,10 +2,10 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { hasDuplicateParamNames } from 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { isInStrictContext } from 'src/utils/paths'
+import { hasDuplicateParamNames } from '../utils/ast'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
+import { isInStrictContext } from '../utils/paths'
 
 /**
  * Replaces `arguments[i]` reads with their mapped parameter in sloppy functions
@@ -113,7 +113,7 @@ function processFunction(path: NodePath<t.Function>): boolean {
   if (path.isArrowFunctionExpression()) {
     return false
   }
-  const { params } = path.node
+  const params = path.node.params
   // Rest, defaults, and destructuring make `arguments` unmapped.
   if (!params.every((param) => t.isIdentifier(param))) {
     return false

package/src/transforms/arrow-to-function.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 { enclosingScopeHasDirectEval, isInsideWith } from 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
+import { enclosingScopeHasDirectEval, isInsideWith } from '../utils/ast'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
 
 /**
  * Lowers arrows with Babel's capture-aware `arrowFunctionToExpression`. Arrows

package/src/transforms/collapse-single-use-temps.ts

@@ -3,17 +3,17 @@ import type { Binding, NodePath, Scope } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { evaluateConstant } from 'src/analysis/constant'
+import { evaluateConstant } from '../analysis/constant'
 import {
   declarationReaches,
   initializerReaches,
   readCrossesFunctionBoundary,
-} from 'src/analysis/document-order'
-import { isPure } from 'src/analysis/purity'
-import { isInsideWith } from 'src/utils/ast'
-import { reorderableToStatement } from 'src/utils/evaluation-order'
-import { valueToLiteral } from 'src/utils/literal'
-import { isCalleeOrTagOf } from 'src/utils/paths'
+} from '../analysis/document-order'
+import { isPure } from '../analysis/purity'
+import { isInsideWith } from '../utils/ast'
+import { reorderableToStatement } from '../utils/evaluation-order'
+import { valueToLiteral } from '../utils/literal'
+import { isCalleeOrTagOf } from '../utils/paths'
 
 /**
  * Drops single-use temporaries through substitution, direct branch writes, or
@@ -125,7 +125,7 @@ function trySubstituteSingleUse(
   binding: Binding,
   declaratorPath: NodePath<t.VariableDeclarator>,
 ): boolean {
-  const [readPath] = binding.referencePaths
+  const readPath = binding.referencePaths[0]
   if (!readPath || !isPathLive(readPath)) {
     return false
   }
@@ -138,7 +138,7 @@ function trySubstituteSingleUse(
     return false
   }
 
-  const { init } = declaratorPath.node
+  const init = declaratorPath.node.init
   let writeStmt: NodePath
   let writeValueOwner: NodePath
   let writeRhs: t.Expression
@@ -255,7 +255,7 @@ function tryRenameWritesToReader(
     return false
   }
 
-  const [readPath] = binding.referencePaths
+  const readPath = binding.referencePaths[0]
   if (!readPath || !isPathLive(readPath)) {
     return false
   }
@@ -389,7 +389,7 @@ function tryScatterIntoTerminator(
     return false
   }
 
-  const [readPath] = binding.referencePaths
+  const readPath = binding.referencePaths[0]
   if (!readPath || !isPathLive(readPath)) {
     return false
   }
@@ -648,7 +648,7 @@ function combineFall(a: boolean | null, b: boolean | null): boolean | null {
 // Apart from redirected writes, the span must run no user code or observations.
 // Redirected right sides must also be pure.
 function spanStatementIsInert(path: NodePath, tempBinding: Binding): boolean {
-  const { node } = path
+  const node = path.node
   if (t.isEmptyStatement(node) || t.isBreakStatement(node) || t.isContinueStatement(node)) {
     return true
   }
@@ -715,7 +715,7 @@ function tryPropagateConstant(
     return false
   }
 
-  const { init } = declaratorPath.node
+  const init = declaratorPath.node.init
   let writeRhs: t.Expression
   let writeRhsPath: NodePath
   let writeStmtToRemove: NodePath | null
@@ -886,7 +886,7 @@ function subtreeReadsBinding(stmtPath: NodePath, target: Binding): boolean {
 }
 
 function isStatementMovementSafe(path: NodePath): boolean {
-  const { node } = path
+  const node = path.node
   if (t.isEmptyStatement(node)) {
     return true
   }

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

@@ -3,9 +3,9 @@ import type { NodePath, Scope, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { initializerReaches } from 'src/analysis/document-order'
-import { enclosingScopeHasDirectEval, isInsideWith } from 'src/utils/ast'
-import { hasConstantViolation } from 'src/utils/paths'
+import { initializerReaches } from '../analysis/document-order'
+import { enclosingScopeHasDirectEval, isInsideWith } from '../utils/ast'
+import { hasConstantViolation } from '../utils/paths'
 
 /**
  * Lifts safe lexical declarations to function-scoped `var`, renaming collisions
@@ -29,7 +29,7 @@ export function constLetToVar(ast: File): boolean {
   const state = { changed: false }
   traverse(ast, {
     VariableDeclaration(path) {
-      const { kind } = path.node
+      const kind = path.node.kind
       if (kind !== 'let' && kind !== 'const') {
         return
       }
@@ -64,7 +64,7 @@ export function constLetToVar(ast: File): boolean {
     },
 
     ClassDeclaration(path) {
-      const { id } = path.node
+      const id = path.node.id
       if (!id) {
         return
       }
@@ -72,7 +72,7 @@ export function constLetToVar(ast: File): boolean {
         return
       }
 
-      const { scope } = path.parentPath
+      const scope = path.parentPath.scope
       if (!isVarScope(scope) && scope.parent!.hasBinding(id.name, { noUids: true })) {
         path.scope.rename(id.name)
         state.changed = true

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

@@ -1,10 +1,10 @@
 import type { Visitor } from '@babel/traverse'
 import type { File } from '@babel/types'
 
-import { enclosingScopeHasDirectEval } from 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { hasConstantViolation } from 'src/utils/paths'
+import { enclosingScopeHasDirectEval } from '../utils/ast'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
+import { hasConstantViolation } from '../utils/paths'
 
 /**
  * Changes `const` to `let` when no write can observe the lost TypeError. Direct

package/src/transforms/do-while-to-while.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 { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { collectLoopLabels, generateLoopLabel, redirectContinues } from 'src/utils/loop-lowering'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
+import { collectLoopLabels, generateLoopLabel, redirectContinues } from '../utils/loop-lowering'
 
 /**
  * Rewrites `do` loops as `while (true)` with an exit test after the body.
@@ -41,8 +41,8 @@ const visitor: Visitor<ChangeState> = {
 }
 
 function transformDoWhile(path: NodePath<t.DoWhileStatement>): void {
-  const { node } = path
-  const { ourLabels } = collectLoopLabels(path)
+  const node = path.node
+  const ourLabels = collectLoopLabels(path).ourLabels
   const innerLabel = generateLoopLabel(path, 'doIteration')
 
   const blockBody: t.BlockStatement = t.isBlockStatement(node.body)
@@ -58,7 +58,7 @@ function transformDoWhile(path: NodePath<t.DoWhileStatement>): void {
     t.blockStatement([labeledBlock, exitTest]),
   )
 
-  const [newPath] = path.replaceWith(whileStmt)
+  const newPath = path.replaceWith(whileStmt)[0]
   const rewriteCount = redirectContinues(newPath, innerLabel, ourLabels)
 
   // Keep the block so body bindings cannot shadow names in the exit test.