webfuscator 1.0.1 → 1.2.0

package/src/transforms/drop-debugger.ts

@@ -2,8 +2,8 @@ import type { 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 every `debugger` statement.

package/src/transforms/expand-binary-assignment.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 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
+import { isInsideWith } from '../utils/ast'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
 
 /**
  * Rewrites arithmetic and bitwise compound assignments as `LHS = LHS op RHS`.
@@ -44,7 +44,9 @@ const visitor: Visitor<ChangeState> = {
 const LOGICAL_COMPOUND = new Set(['||', '&&', '??'])
 
 function lowerBinaryAssignment(path: NodePath<t.AssignmentExpression>): boolean {
-  const { operator, left, right } = path.node
+  const operator = path.node.operator
+  const left = path.node.left
+  const right = path.node.right
   if (operator === '=' || operator.length < 2) {
     return false
   }
@@ -60,7 +62,7 @@ function lowerBinaryAssignment(path: NodePath<t.AssignmentExpression>): boolean
     if (isInsideWith(path)) {
       return false
     }
-    const { object } = left
+    const object = left.object
     if (t.isExpression(object)) {
       const memo = path.scope.maybeGenerateMemoised(object)
       if (memo) {
@@ -70,7 +72,7 @@ function lowerBinaryAssignment(path: NodePath<t.AssignmentExpression>): boolean
     }
 
     if (left.computed) {
-      const { property } = left
+      const property = left.property
       if (t.isExpression(property)) {
         const memoProp = path.scope.maybeGenerateMemoised(property)
         if (memoProp) {

package/src/transforms/expand-logical-assignment.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 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
+import { isInsideWith } from '../utils/ast'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
 
 /**
  * Rewrites `||=`/`&&=`/`??=` as `LHS op (LHS = RHS)`. Member objects and
@@ -38,7 +38,9 @@ const visitor: Visitor<ChangeState> = {
 }
 
 function lowerLogicalAssignment(path: NodePath<t.AssignmentExpression>): boolean {
-  const { operator, left, right } = path.node
+  const operator = path.node.operator
+  const left = path.node.left
+  const right = path.node.right
   if (operator.length < 2) {
     return false
   }
@@ -54,7 +56,7 @@ function lowerLogicalAssignment(path: NodePath<t.AssignmentExpression>): boolean
     if (isInsideWith(path)) {
       return false
     }
-    const { object } = left
+    const object = left.object
     if (t.isExpression(object)) {
       const memo = path.scope.maybeGenerateMemoised(object)
       if (memo) {
@@ -64,7 +66,7 @@ function lowerLogicalAssignment(path: NodePath<t.AssignmentExpression>): boolean
     }
 
     if (left.computed) {
-      const { property } = left
+      const property = left.property
       if (t.isExpression(property)) {
         const memoProp = path.scope.maybeGenerateMemoised(property)
         if (memoProp) {

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

@@ -2,11 +2,11 @@ import type { Binding, NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { initializerReaches } from 'src/analysis/document-order'
-import { isInsideWith, isProtoKey } from 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { isCalleeOrTagOf } from 'src/utils/paths'
+import { initializerReaches } from '../analysis/document-order'
+import { isInsideWith, isProtoKey } from '../utils/ast'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
+import { isCalleeOrTagOf } from '../utils/paths'
 
 /**
  * Replaces a constant object or array wrapper with one binding per entry when
@@ -48,7 +48,7 @@ function tryExtractDeclaration(path: NodePath<t.VariableDeclaration>): boolean {
   if (path.key === 'init' && path.parentPath?.isForStatement() && path.node.kind !== 'var') {
     return false
   }
-  const [declaratorPath] = path.get('declarations')
+  const declaratorPath = path.get('declarations')[0]
   if (!declaratorPath) {
     return false
   }
@@ -239,7 +239,7 @@ function performExtraction(
     replacements.push({ memberPath: parent, key })
   }
 
-  const { scope } = path
+  const scope = path.scope
   const usedNames = new Set<string>()
   const keyToName = new Map<string, string>()
   for (const { key } of entries) {
@@ -257,9 +257,9 @@ function performExtraction(
     keyToName.set(key, chosen)
   }
 
-  const newDecls = entries.map(({ key, value }) =>
+  const newDecls = entries.map((entry) =>
     t.variableDeclaration(path.node.kind, [
-      t.variableDeclarator(t.identifier(keyToName.get(key)!), value),
+      t.variableDeclarator(t.identifier(keyToName.get(entry.key)!), entry.value),
     ]),
   )
 
@@ -271,7 +271,7 @@ function performExtraction(
   // Publish rewritten references for the next fixed-point iteration.
   for (const { memberPath, key } of replacements) {
     const name = keyToName.get(key)!
-    const [newRefPath] = memberPath.replaceWith(t.identifier(name))
+    const newRefPath = memberPath.replaceWith(t.identifier(name))[0]
     if (newRefPath) {
       const refBinding = newRefPath.scope.getBinding(name)
       if (refBinding) {
@@ -288,7 +288,7 @@ function performExtraction(
 }
 
 function staticPropertyKey(prop: t.ObjectProperty): string | null {
-  const { key } = prop
+  const key = prop.key
   if (!prop.computed && t.isIdentifier(key)) {
     return key.name
   }
@@ -359,7 +359,7 @@ function isWriteTargetMember(memberPath: NodePath<t.MemberExpression>): boolean
 }
 
 function functionRefsThis(path: NodePath): boolean {
-  const { node } = path
+  const node = path.node
   if (!t.isFunctionExpression(node) && !t.isFunctionDeclaration(node)) {
     return false
   }

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

@@ -3,10 +3,10 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { evaluateConstant, isOpaque } from 'src/analysis/constant'
-import { enclosingScopeHasDirectEval, isInDirectivePrologue, isInsideWith } from 'src/utils/ast'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { valueToLiteral } from 'src/utils/literal'
+import { evaluateConstant, isOpaque } from '../analysis/constant'
+import { enclosingScopeHasDirectEval, isInDirectivePrologue, isInsideWith } from '../utils/ast'
+import type { ChangeState } from '../utils/change-tracking'
+import { valueToLiteral } from '../utils/literal'
 
 /**
  * Replaces built-in calls and reads with smaller syntax or host-computed
@@ -105,7 +105,7 @@ function collectPatchedIntrinsics(ast: File): Set<string> {
     },
     Identifier(path) {
       // Global eval and Function can patch any intrinsic outside this scan.
-      const { name } = path.node
+      const name = path.node.name
       if (name !== 'eval' && name !== 'Function') {
         return
       }
@@ -163,7 +163,7 @@ function markWriteTarget(target: t.Node, scope: NodePath['scope'], poison: Poiso
 
 // Only genuine Object and Reflect bulk mutation methods count as patches.
 function markMutationCall(path: NodePath<t.CallExpression>, poison: PoisonSink): void {
-  const { callee } = path.node
+  const callee = path.node.callee
   // Preparation may already have changed the method to bracket syntax.
   if (!t.isMemberExpression(callee) || !t.isIdentifier(callee.object)) {
     return
@@ -175,7 +175,7 @@ function markMutationCall(path: NodePath<t.CallExpression>, poison: PoisonSink):
   if (!isMutatingIntrinsicMethod(callee.object.name, method)) {
     return
   }
-  const [firstArg] = path.node.arguments
+  const firstArg = path.node.arguments[0]
   if (!firstArg || !t.isExpression(firstArg)) {
     return
   }
@@ -461,12 +461,12 @@ function staticPropertyName(node: t.MemberExpression): string | null {
 // Write targets require references. A folded literal would be invalid syntax,
 // including when the member sits inside a destructuring target.
 function isReferenceRequiredPosition(path: NodePath<t.MemberExpression>): boolean {
-  const { parentPath } = path
+  const parentPath = path.parentPath
   if (!parentPath) {
     return false
   }
   const parent = parentPath.node
-  const { node } = path
+  const node = path.node
   if (t.isAssignmentExpression(parent) && parent.left === node) {
     return true
   }
@@ -500,7 +500,7 @@ function foldsIntoDirective(path: NodePath<t.CallExpression>, replacement: t.Exp
   if (!t.isStringLiteral(replacement)) {
     return false
   }
-  const { parentPath } = path
+  const parentPath = path.parentPath
   return (
     parentPath != null && parentPath.isExpressionStatement() && isInDirectivePrologue(parentPath)
   )
@@ -511,7 +511,7 @@ function handleCall(path: NodePath<t.CallExpression>, patchedRoots: Set<string>)
   if (isInsideWith(path) || enclosingScopeHasDirectEval(path)) {
     return
   }
-  const { callee } = path.node
+  const callee = path.node.callee
 
   if (t.isIdentifier(callee)) {
     foldGlobalCall(path, callee.name, patchedRoots)
@@ -545,7 +545,7 @@ function handleMember(path: NodePath<t.MemberExpression>, patchedRoots: Set<stri
     return
   }
 
-  const { parent } = path
+  const parent = path.parent
   // Calls use their own folding path.
   if (
     (t.isCallExpression(parent) ||
@@ -700,7 +700,7 @@ function foldReceiverCall(
   if (!recv.known) {
     return
   }
-  const { value } = recv
+  const value = recv.value
 
   if (typeof value === 'string') {
     if (!STRING_PROTOTYPE_METHODS.has(method) || patchedRoots.has('String')) {
@@ -736,7 +736,8 @@ function foldMathPow(path: NodePath<t.CallExpression>): void {
   if (args.length !== 2) {
     return
   }
-  const [left, right] = args
+  const left = args[0]
+  const right = args[1]
   if (!t.isExpression(left) || !t.isExpression(right)) {
     return
   }
@@ -778,7 +779,7 @@ function foldArrayIsArray(path: NodePath<t.CallExpression>): void {
   if (args.length !== 1) {
     return
   }
-  const [arg] = args
+  const arg = args[0]
   if (!t.isExpression(arg)) {
     return
   }
@@ -787,7 +788,7 @@ function foldArrayIsArray(path: NodePath<t.CallExpression>): void {
   if (!evaluated.known) {
     return
   }
-  const { value } = evaluated
+  const value = evaluated.value
   if (
     typeof value === 'string' ||
     typeof value === 'number' ||
@@ -809,7 +810,7 @@ function foldBooleanCtor(path: NodePath<t.CallExpression>): void {
   if (args.length !== 1) {
     return
   }
-  const [arg] = args
+  const arg = args[0]
   if (!t.isExpression(arg)) {
     return
   }
@@ -828,7 +829,7 @@ function foldStringCtor(path: NodePath<t.CallExpression>): void {
   if (args.length !== 1) {
     return
   }
-  const [arg] = args
+  const arg = args[0]
   if (!t.isExpression(arg)) {
     return
   }
@@ -858,7 +859,7 @@ function foldNumberCtor(path: NodePath<t.CallExpression>): void {
   if (args.length !== 1) {
     return
   }
-  const [arg] = args
+  const arg = args[0]
   if (!t.isExpression(arg)) {
     return
   }

package/src/transforms/fold-constants.ts

@@ -2,12 +2,12 @@ import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { evaluateConstant } from 'src/analysis/constant'
-import { isPure } from 'src/analysis/purity'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { valueToLiteral } from 'src/utils/literal'
-import { isCalleeOrTagOf } from 'src/utils/paths'
+import { evaluateConstant } from '../analysis/constant'
+import { isPure } from '../analysis/purity'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
+import { valueToLiteral } from '../utils/literal'
+import { isCalleeOrTagOf } from '../utils/paths'
 
 /**
  * Folds pure constant expressions to literals via `evaluateConstant`.
@@ -243,7 +243,7 @@ function tryReassociateSubtract(path: NodePath<t.BinaryExpression>): boolean {
   let node: t.BinaryExpression = path.node
   while (true) {
     subtractees.unshift(node.right)
-    const { left } = node
+    const left = node.left
     if (t.isBinaryExpression(left) && left.operator === '-') {
       node = left
       continue
@@ -359,7 +359,7 @@ function combineConstants(
   if (consts.length === 0) {
     return null
   }
-  const { kind } = consts[0]!
+  const kind = consts[0]!.kind
   for (const c of consts) {
     if (c.kind !== kind) {
       return null

package/src/transforms/for-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 classic `for` loops as an initializer followed by `while`. Continues
@@ -45,14 +45,14 @@ const visitor: Visitor<ChangeState> = {
 }
 
 function transformFor(path: NodePath<t.ForStatement>): boolean {
-  const { node } = path
+  const node = path.node
 
   // One hoisted binding cannot preserve lexical per-iteration captures.
   if (t.isVariableDeclaration(node.init) && node.init.kind !== 'var') {
     return false
   }
 
-  const { outermost, ourLabels } = collectLoopLabels(path)
+  const loopLabels = collectLoopLabels(path)
   const innerLabel = generateLoopLabel(path, 'forIteration')
 
   const initStmt = buildInitStatement(node.init)
@@ -71,8 +71,8 @@ function transformFor(path: NodePath<t.ForStatement>): boolean {
   const test = node.test ?? t.booleanLiteral(true)
   const whileStmt = t.whileStatement(test, t.blockStatement(whileBody))
 
-  const [newPath] = path.replaceWith(whileStmt)
-  const rewriteCount = redirectContinues(newPath, innerLabel, ourLabels)
+  const newPath = path.replaceWith(whileStmt)[0]
+  const rewriteCount = redirectContinues(newPath, innerLabel, loopLabels.ourLabels)
 
   // Keep the block so body bindings cannot shadow names in the update.
   if (rewriteCount === 0) {
@@ -80,7 +80,7 @@ function transformFor(path: NodePath<t.ForStatement>): boolean {
     whileBlock.body[0] = blockBody
   }
 
-  hoistInit(outermost, initStmt)
+  hoistInit(loopLabels.outermost, initStmt)
   return true
 }
 

package/src/transforms/function-declaration-to-expression.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'
 
 /**
  * Rewrites safe function declarations as `var` initializers. The function value
@@ -36,11 +36,11 @@ export function functionDeclarationToExpression(ast: File): boolean {
 
 const visitor: Visitor<ChangeState> = {
   FunctionDeclaration(path, state) {
-    const { id } = path.node
+    const id = path.node.id
     if (!id || !isConvertible(path, id)) {
       return
     }
-    const { node } = path
+    const node = path.node
     const fn = t.functionExpression(null, node.params, node.body, node.generator, node.async)
     path.replaceWith(t.variableDeclaration('var', [t.variableDeclarator(t.cloneNode(id), fn)]))
     state.changed = true
@@ -66,7 +66,7 @@ function isConvertible(path: NodePath<t.FunctionDeclaration>, id: t.Identifier):
     return false
   }
 
-  const { body } = parent.node as t.Program | t.BlockStatement
+  const body = (parent.node as t.Program | t.BlockStatement).body
   const index = path.key as number
   for (let i = 0; i < index; i++) {
     if (!isInertStatement(body[i]!)) {

package/src/transforms/inline-functions.ts

@@ -3,13 +3,13 @@ import type { NodePath, Scope } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { analyzeInlineability } from 'src/analysis/inlineability'
-import type { InlineCandidate } from 'src/analysis/inlineability'
-import { isPure } from 'src/analysis/purity'
-import { enclosingScopeHasDirectEval, isInsideWith, walkOwnFunctionScope } from 'src/utils/ast'
-import { reorderableToStatement } from 'src/utils/evaluation-order'
-import { generateLoopLabel } from 'src/utils/loop-lowering'
-import { hasAnnexBFunctionAlias, isInStrictContext } from 'src/utils/paths'
+import { analyzeInlineability } from '../analysis/inlineability'
+import type { InlineCandidate } from '../analysis/inlineability'
+import { isPure } from '../analysis/purity'
+import { enclosingScopeHasDirectEval, isInsideWith, walkOwnFunctionScope } from '../utils/ast'
+import { reorderableToStatement } from '../utils/evaluation-order'
+import { generateLoopLabel } from '../utils/loop-lowering'
+import { hasAnnexBFunctionAlias, isInStrictContext } from '../utils/paths'
 
 /**
  * Replaces eligible calls with function bodies, working from inner calls out.
@@ -59,7 +59,7 @@ function tryInlineAtCallExpr(
   path: NodePath<t.CallExpression>,
   candidates: Map<string, InlineCandidate>,
 ): boolean {
-  const { callee } = path.node
+  const callee = path.node.callee
   if (!t.isIdentifier(callee)) {
     return false
   }
@@ -123,7 +123,7 @@ function declarationIdentifier(declPath: NodePath): t.Identifier | null {
     return declPath.node.id ?? null
   }
   if (declPath.isVariableDeclaration() && declPath.node.declarations.length === 1) {
-    const { id } = declPath.node.declarations[0]!
+    const id = declPath.node.declarations[0]!.id
     return t.isIdentifier(id) ? id : null
   }
   return null
@@ -209,7 +209,7 @@ function annexBHoistShadowsFreeVar(
       path.skip()
     },
     FunctionDeclaration(path) {
-      const { id } = path.node
+      const id = path.node.id
       if (id && freeVars.has(id.name) && hasAnnexBFunctionAlias(path)) {
         found = true
         path.stop()
@@ -463,7 +463,7 @@ function inlineCallSite(
     return false
   }
 
-  const { scope } = stmtParent
+  const scope = stmtParent.scope
   const labelName = generateLoopLabel(stmtParent, 'inlined')
 
   // Returns can write directly into a bare assignment or `var` initializer.
@@ -660,7 +660,7 @@ function identifyDirectAssignmentTarget(
     if (owner.isForOfStatement() && owner.node.left === declPath.node) {
       return null
     }
-    const { name } = parent.node.id
+    const name = parent.node.id.name
     if (freeVars.has(name)) {
       return null
     }
@@ -680,7 +680,7 @@ function identifyDirectAssignmentTarget(
     if (!stmt || !stmt.isExpressionStatement() || stmt.node.expression !== parent.node) {
       return null
     }
-    const { name } = parent.node.left
+    const name = parent.node.left.name
     if (freeVars.has(name)) {
       return null
     }
@@ -782,7 +782,7 @@ function computeLiveFreeVars(candidate: InlineCandidate): Set<string> {
       if (slot && isNonReferenceSlot(slot.node, slot.key)) {
         return
       }
-      const { name } = node
+      const name = node.name
       if (ownBound.has(name) || shadows.covers(name)) {
         return
       }

package/src/transforms/logical-to-ternary.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 { isPure } from 'src/analysis/purity'
-import { isInsideWith } from 'src/utils/ast'
-import { traverseForChanges } from 'src/utils/change-tracking'
-import type { ChangeState } from 'src/utils/change-tracking'
-import { lowerLogicalWriteStatement } from 'src/utils/logical-lowering'
+import { isPure } from '../analysis/purity'
+import { isInsideWith } from '../utils/ast'
+import { traverseForChanges } from '../utils/change-tracking'
+import type { ChangeState } from '../utils/change-tracking'
+import { lowerLogicalWriteStatement } from '../utils/logical-lowering'
 
 /**
  * Rewrites logical expressions as guarded assignments or ternaries. A
@@ -40,7 +40,7 @@ const visitor: Visitor<ChangeState> = {
 }
 
 function lowerLogical(path: NodePath<t.LogicalExpression>): boolean {
-  const { node } = path
+  const node = path.node
   const op = node.operator
   if (op !== '&&' && op !== '||' && op !== '??') {
     return false
@@ -54,7 +54,7 @@ function lowerLogical(path: NodePath<t.LogicalExpression>): boolean {
     return true
   }
 
-  const { scope } = path
+  const scope = path.scope
   const leftPath = path.get('left')
   let testSrc: t.Expression
   let valueSrc: t.Expression