webfuscator 1.2.1 → 1.3.1

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

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

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

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

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

@@ -1,12 +1,10 @@
 import traverse from '@babel/traverse'
-import type { NodePath, Scope, Visitor } from '@babel/traverse'
+import type { NodePath, Visitor } from '@babel/traverse'
 import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
 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.
@@ -28,10 +26,7 @@ export function removeUnusedCode(ast: File): boolean {
   // then maintain counts during removal.
   crawlProgramScope(ast)
   let anyChanged = false
-  const state: SweepState = {
-    changed: true,
-    evalReachableScopes: collectEvalReachableScopes(ast),
-  }
+  const state: ChangeState = { changed: true }
   while (state.changed) {
     state.changed = false
     traverse(ast, sweepVisitor, undefined, state)
@@ -51,49 +46,19 @@ function crawlProgramScope(ast: File): void {
   })
 }
 
-// Direct eval can read otherwise unreferenced bindings in its scope ancestry.
-// Sweep state keeps this set local to one pass.
-interface SweepState extends ChangeState {
-  evalReachableScopes: Set<t.Node>
-}
-
-function collectEvalReachableScopes(ast: File): Set<t.Node> {
-  const reachable = new Set<t.Node>()
-  traverse(ast, {
-    CallExpression(path) {
-      if (!isDirectEvalCall(path.node)) {
-        return
-      }
-      let scope: Scope | undefined = path.scope
-      while (scope) {
-        reachable.add(scope.block)
-        scope = scope.parent
-      }
-    },
-  })
-  return reachable
-}
-
-function bindingReachableByEval(
-  binding: { scope: Scope },
-  evalReachableScopes: Set<t.Node>,
-): boolean {
-  return evalReachableScopes.has(binding.scope.block)
-}
-
-const sweepVisitor: Visitor<SweepState> = {
+const sweepVisitor: Visitor<ChangeState> = {
   VariableDeclarator(path, state) {
-    if (tryRemoveDeclarator(path, state.evalReachableScopes)) {
+    if (tryRemoveDeclarator(path)) {
       state.changed = true
     }
   },
   FunctionDeclaration(path, state) {
-    if (tryRemoveFunctionDecl(path, state.evalReachableScopes)) {
+    if (tryRemoveFunctionDecl(path)) {
       state.changed = true
     }
   },
   ClassDeclaration(path, state) {
-    if (tryRemoveClassDecl(path, state.evalReachableScopes)) {
+    if (tryRemoveClassDecl(path)) {
       state.changed = true
     }
   },
@@ -126,10 +91,7 @@ function dereferenceSubtree(rootPath: NodePath): void {
   rootPath.traverse(dereferenceVisitor)
 }
 
-function tryRemoveDeclarator(
-  path: NodePath<t.VariableDeclarator>,
-  evalReachableScopes: Set<t.Node>,
-): boolean {
+function tryRemoveDeclarator(path: NodePath<t.VariableDeclarator>): boolean {
   const declaration = path.parentPath
   if (!declaration || !declaration.isVariableDeclaration()) {
     return false
@@ -156,7 +118,7 @@ function tryRemoveDeclarator(
   }
 
   const init = path.node.init
-  if (init && !isSideEffectFree(init, path.scope, path.get('init') as NodePath)) {
+  if (init && !isSideEffectFree(init, path.scope)) {
     return false
   }
 
@@ -167,13 +129,9 @@ function tryRemoveDeclarator(
   if (binding.references > 0) {
     return false
   }
-  if (binding.constantViolations.length > 0) {
-    return false
-  }
-  if (bindingReachableByEval(binding, evalReachableScopes)) {
+  if (declaration.node.kind !== 'const' && binding.constantViolations.length > 0) {
     return false
   }
-
   if (path.node.init) {
     dereferenceSubtree(path.get('init') as NodePath)
   }
@@ -185,17 +143,10 @@ function tryRemoveDeclarator(
   return true
 }
 
-function tryRemoveFunctionDecl(
-  path: NodePath<t.FunctionDeclaration>,
-  evalReachableScopes: Set<t.Node>,
-): boolean {
+function tryRemoveFunctionDecl(path: NodePath<t.FunctionDeclaration>): boolean {
   if (isExported(path)) {
     return false
   }
-  // Babel misses the sloppy Annex B alias of a block-level function.
-  if (hasAnnexBFunctionAlias(path)) {
-    return false
-  }
   const id = path.node.id
   if (!id) {
     return false
@@ -211,20 +162,13 @@ function tryRemoveFunctionDecl(
   if (binding.constantViolations.length > 0) {
     return false
   }
-  if (bindingReachableByEval(binding, evalReachableScopes)) {
-    return false
-  }
-
   dereferenceSubtree(path.get('body') as NodePath)
   path.scope.removeBinding(id.name)
   path.remove()
   return true
 }
 
-function tryRemoveClassDecl(
-  path: NodePath<t.ClassDeclaration>,
-  evalReachableScopes: Set<t.Node>,
-): boolean {
+function tryRemoveClassDecl(path: NodePath<t.ClassDeclaration>): boolean {
   if (isExported(path)) {
     return false
   }
@@ -234,7 +178,7 @@ function tryRemoveClassDecl(
   }
 
   // `extends`, computed keys, static fields, and static blocks run on evaluation.
-  if (path.node.superClass && !isSideEffectFree(path.node.superClass, path.scope, path)) {
+  if (path.node.superClass && !isSideEffectFree(path.node.superClass, path.scope)) {
     return false
   }
   for (const member of path.node.body.body) {
@@ -249,7 +193,7 @@ function tryRemoveClassDecl(
       'computed' in member &&
       member.computed &&
       'key' in member &&
-      !isSideEffectFree(member.key, path.scope, path)
+      !isSideEffectFree(member.key, path.scope)
     ) {
       return false
     }
@@ -265,10 +209,6 @@ function tryRemoveClassDecl(
   if (binding.constantViolations.length > 0) {
     return false
   }
-  if (bindingReachableByEval(binding, evalReachableScopes)) {
-    return false
-  }
-
   dereferenceSubtree(path.get('body') as NodePath)
   if (path.node.superClass) {
     dereferenceSubtree(path.get('superClass') as NodePath)
@@ -279,7 +219,7 @@ function tryRemoveClassDecl(
 }
 
 function tryRemoveExpressionStatement(path: NodePath<t.ExpressionStatement>): boolean {
-  if (!isSideEffectFree(path.node.expression, path.scope, path.get('expression'))) {
+  if (!isSideEffectFree(path.node.expression, path.scope)) {
     return false
   }
   dereferenceSubtree(path.get('expression') as NodePath)

package/src/transforms/rename-identifiers.ts

@@ -4,15 +4,14 @@ import * as t from '@babel/types'
 import type { File } from '@babel/types'
 
 import type { TransformContext } from '../options'
-import { isDirectEvalCall, isInsideWith } from '../utils/ast'
-import { hasAnnexBFunctionAlias, referencesOrWritesVariable } from '../utils/paths'
+import { referencesOrWritesVariable } from '../utils/paths'
 import { mulberry32 } from '../utils/random'
 import { StringGenerator } from '../utils/string-generator'
 
 /**
- * Renames bindings and labels with a fresh `StringGenerator`. Each scope avoids
- * live ancestor names but otherwise restarts the cursor, allowing safe reuse in
- * sibling scopes.
+ * Renames bindings and labels with the configured string generator. Generated
+ * names do not capture unresolved names or bindings still used from an outer
+ * scope. Separate sibling scopes may reuse the same names.
  *
  * @example
  * // ◀️ before
@@ -31,6 +30,7 @@ import { StringGenerator } from '../utils/string-generator'
  */
 export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
   const generator = new StringGenerator(ctx.stringGeneratorMode, mulberry32(ctx.seed))
+  const separatedDirectExports = separateDirectExports(ast.program)
 
   let programScope: Scope | undefined
   traverse(ast, {
@@ -40,14 +40,13 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
     },
   })
   if (!programScope) {
-    return false
+    return separatedDirectExports
   }
   programScope.crawl()
 
   const liveAncestors = new Map<Scope, Set<Binding>>()
   // Reserve unbound names so generated bindings cannot capture them.
   const freeNames = new Set<string>()
-  // `with` and direct eval pin bindings to their source names.
   const unrenamable = new Set<Binding>()
   // Reserve pinned source names globally, including before their binding is seen.
   const pinnedNames = new Set<string>()
@@ -68,9 +67,6 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
         }
         return
       }
-      if (isInsideWith(path)) {
-        pin(binding, path.node.name)
-      }
       let scope: Scope | undefined = path.scope
       while (scope && scope !== binding.scope) {
         let live = liveAncestors.get(scope)
@@ -82,30 +78,6 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
         scope = scope.parent
       }
     },
-    CallExpression(path) {
-      // Direct eval can read every visible binding by its source name.
-      if (!isDirectEvalCall(path.node)) {
-        return
-      }
-      let scope: Scope | undefined = path.scope
-      while (scope) {
-        for (const name of Object.keys(scope.bindings)) {
-          pin(scope.bindings[name]!, name)
-        }
-        scope = scope.parent
-      }
-    },
-    FunctionDeclaration(path) {
-      // ECMA-262 B.3.3 gives sloppy block functions an alias Babel does not model.
-      if (!hasAnnexBFunctionAlias(path)) {
-        return
-      }
-      const name = path.node.id?.name
-      const binding = name === undefined ? undefined : path.scope.getBinding(name)
-      if (binding && name !== undefined) {
-        pin(binding, name)
-      }
-    },
     CatchClause(path) {
       // Babel splits a catch parameter and same-named `var` that share one runtime
       // variable. They must keep the same name.
@@ -169,7 +141,7 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
   })
 
   if (bindingToName.size === 0) {
-    return renameLabels(ast, generator)
+    return renameLabels(ast, generator) || separatedDirectExports
   }
 
   traverse(ast, {
@@ -199,6 +171,43 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
   return true
 }
 
+function separateDirectExports(program: t.Program): boolean {
+  const body: t.Program['body'] = []
+  let changed = false
+
+  for (const statement of program.body) {
+    const declaration = t.isExportNamedDeclaration(statement) ? statement.declaration : null
+    if (
+      !t.isVariableDeclaration(declaration) &&
+      !t.isFunctionDeclaration(declaration) &&
+      !t.isClassDeclaration(declaration)
+    ) {
+      body.push(statement)
+      continue
+    }
+
+    const names = Object.keys(t.getBindingIdentifiers(declaration))
+    if (names.length === 0) {
+      body.push(statement)
+      continue
+    }
+
+    body.push(
+      declaration,
+      t.exportNamedDeclaration(
+        null,
+        names.map((name) => t.exportSpecifier(t.identifier(name), t.identifier(name))),
+      ),
+    )
+    changed = true
+  }
+
+  if (changed) {
+    program.body = body
+  }
+  return changed
+}
+
 function isNonBindingPosition(path: { node: t.Identifier; parent: t.Node }): boolean {
   const node = path.node
   const parent = path.parent

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

@@ -0,0 +1,78 @@
+import type { NodePath } from '@babel/traverse'
+import type * as t from '@babel/types'
+import type { File } from '@babel/types'
+
+import { rewriteStatementLists } from '../utils/statement-lists'
+import type { StatementListContainer } from '../utils/statement-lists'
+
+/**
+ * Moves hoisted function declarations to the end of each program, block, switch
+ * case, or static block. It keeps declaration order, including duplicate names.
+ *
+ * If moving every declaration would turn a string expression into a directive,
+ * one declaration stays before the string. Direct exports stay in place.
+ * Indirect exports move with their local declaration.
+ *
+ * @example
+ * // ◀️ before
+ * function area(r) {
+ *   return r * r;
+ * }
+ * log(area(2));
+ *
+ * // ▶️ after
+ * log(area(2));
+ * function area(r) {
+ *   return r * r;
+ * }
+ */
+export function reorderFunctionDeclarations(ast: File): boolean {
+  return rewriteStatementLists(ast, (statements, container) =>
+    reorderedStatements(statements, containerAllowsDirective(container)),
+  )
+}
+
+// Only programs and function bodies recognize directives, so only they need the guard.
+function containerAllowsDirective(container: NodePath<StatementListContainer>): boolean {
+  if (container.isProgram()) {
+    return true
+  }
+  return container.isBlockStatement() && container.parentPath.isFunction()
+}
+
+function reorderedStatements(
+  children: NodePath<t.Statement>[],
+  canCreateDirective: boolean,
+): t.Statement[] | null {
+  const rest: t.Statement[] = []
+  const moved: t.Statement[] = []
+  for (const child of children) {
+    if (isMovable(child)) {
+      moved.push(child.node)
+    } else {
+      rest.push(child.node)
+    }
+  }
+
+  if (moved.length === 0) {
+    return null
+  }
+  if (canCreateDirective && createsDirective(rest)) {
+    rest.unshift(moved.shift()!)
+  }
+  const reordered = [...rest, ...moved]
+  return reordered.every((node, index) => node === children[index]?.node) ? null : reordered
+}
+
+function createsDirective(statements: readonly t.Statement[]): boolean {
+  const first = statements[0]
+  return (
+    first !== undefined &&
+    first.type === 'ExpressionStatement' &&
+    first.expression.type === 'StringLiteral'
+  )
+}
+
+function isMovable(child: NodePath<t.Statement>): boolean {
+  return child.isFunctionDeclaration() && child.node.id !== null
+}

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

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

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

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

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

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