webfuscator 0.9.4

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

@@ -0,0 +1,84 @@
+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'
+
+/**
+ * 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.
+ *
+ * @example
+ * // ◀️ before
+ * var greet = function greet() {};
+ * var a = function bar() {};
+ *
+ * // ▶️ after
+ * var greet = function () {};
+ * var a = function bar() {};
+ */
+export function removeAnonymousFunctionNames(ast: File): boolean {
+  return traverseForChanges(ast, visitor)
+}
+
+const visitor: Visitor<ChangeState> = {
+  FunctionExpression(path, state) {
+    const { id } = path.node
+    if (!id) {
+      return
+    }
+    // Reads and writes both observe the expression's immutable inner binding.
+    const binding = path.scope.getBinding(id.name)
+    if (
+      binding &&
+      binding.identifier === id &&
+      (binding.references > 0 || binding.constantViolations.length > 0)
+    ) {
+      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
+  const { parentPath } = path
+  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

@@ -0,0 +1,115 @@
+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'
+
+/**
+ * Removes statements after unconditional control flow in the same statement list.
+ *
+ * Hoisted function and `var` declarations stay because reachable code may still
+ * observe their bindings.
+ *
+ * @example
+ * // ◀️ before
+ * function foo() {
+ *   return "bar";
+ *   log("baz");
+ * }
+ *
+ * // ▶️ after
+ * function foo() {
+ *   return "bar";
+ * }
+ */
+export function removeUnreachableCode(ast: File): boolean {
+  return traverseForChanges(ast, visitor)
+}
+
+const visitor: Visitor<ChangeState> = {
+  BlockStatement(path, state) {
+    if (pruneBody(path.get('body'))) {
+      state.changed = true
+    }
+  },
+  SwitchCase(path, state) {
+    if (pruneBody(path.get('consequent'))) {
+      state.changed = true
+    }
+  },
+}
+
+function pruneBody(body: NodePath<t.Statement>[]): boolean {
+  let killZone = false
+  const toRemove: NodePath<t.Statement>[] = []
+  for (const stmt of body) {
+    if (killZone) {
+      if (isSafeToRemoveAfterCompletion(stmt)) {
+        toRemove.push(stmt)
+      }
+      continue
+    }
+    if (isCompletion(stmt.node)) {
+      killZone = true
+    }
+  }
+  for (const removed of toRemove) {
+    removed.remove()
+  }
+  return toRemove.length > 0
+}
+
+function isCompletion(node: t.Node): boolean {
+  return (
+    t.isReturnStatement(node) ||
+    t.isThrowStatement(node) ||
+    t.isBreakStatement(node) ||
+    t.isContinueStatement(node)
+  )
+}
+
+// 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
+  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
+}
+
+function nestsHoistedDeclaration(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') {
+      found = true
+    }
+    return found ? t.traverseFast.skip : undefined
+  })
+  return found
+}

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

@@ -0,0 +1,296 @@
+import traverse from '@babel/traverse'
+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'
+
+/**
+ * Removes unused declarations and expression statements that have no effects.
+ * Sweeps continue because each removal can strand another binding.
+ *
+ * @example
+ * // ◀️ before
+ * function foo() { return "foo"; }
+ * function bar() { return "bar"; }
+ * var unused = 1;
+ * foo();
+ *
+ * // ▶️ after
+ * function foo() { return "foo"; }
+ * foo();
+ */
+export function removeUnusedCode(ast: File): boolean {
+  // Earlier relocation can leave references on detached paths. Rebuild once,
+  // then maintain counts during removal.
+  crawlProgramScope(ast)
+  let anyChanged = false
+  const state: SweepState = {
+    changed: true,
+    evalReachableScopes: collectEvalReachableScopes(ast),
+  }
+  while (state.changed) {
+    state.changed = false
+    traverse(ast, sweepVisitor, undefined, state)
+    if (state.changed) {
+      anyChanged = true
+    }
+  }
+  return anyChanged
+}
+
+function crawlProgramScope(ast: File): void {
+  traverse(ast, {
+    Program(path) {
+      path.scope.crawl()
+      path.stop()
+    },
+  })
+}
+
+// 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> = {
+  VariableDeclarator(path, state) {
+    if (tryRemoveDeclarator(path, state.evalReachableScopes)) {
+      state.changed = true
+    }
+  },
+  FunctionDeclaration(path, state) {
+    if (tryRemoveFunctionDecl(path, state.evalReachableScopes)) {
+      state.changed = true
+    }
+  },
+  ClassDeclaration(path, state) {
+    if (tryRemoveClassDecl(path, state.evalReachableScopes)) {
+      state.changed = true
+    }
+  },
+  ExpressionStatement(path, state) {
+    if (tryRemoveExpressionStatement(path)) {
+      state.changed = true
+    }
+  },
+}
+
+const dereferenceVisitor: Visitor = {
+  Identifier(path) {
+    if (!path.isReferencedIdentifier()) {
+      return
+    }
+    const binding = path.scope.getBinding(path.node.name)
+    if (binding) {
+      binding.dereference()
+    }
+  },
+}
+
+function dereferenceSubtree(rootPath: NodePath): void {
+  if (rootPath.isReferencedIdentifier()) {
+    const binding = rootPath.scope.getBinding((rootPath.node as t.Identifier).name)
+    if (binding) {
+      binding.dereference()
+    }
+  }
+  rootPath.traverse(dereferenceVisitor)
+}
+
+function tryRemoveDeclarator(
+  path: NodePath<t.VariableDeclarator>,
+  evalReachableScopes: Set<t.Node>,
+): boolean {
+  const declaration = path.parentPath
+  if (!declaration || !declaration.isVariableDeclaration()) {
+    return false
+  }
+
+  const grandparent = declaration.parentPath
+  if (!grandparent) {
+    return false
+  }
+  if (grandparent.isExportNamedDeclaration() || grandparent.isExportDefaultDeclaration()) {
+    return false
+  }
+  if (
+    grandparent.isForStatement() ||
+    grandparent.isForInStatement() ||
+    grandparent.isForOfStatement()
+  ) {
+    return false
+  }
+
+  const { id } = path.node
+  if (!t.isIdentifier(id)) {
+    return false
+  }
+
+  const { init } = path.node
+  if (init && !isSideEffectFree(init, path.scope, path.get('init') as NodePath)) {
+    return false
+  }
+
+  const binding = path.scope.getBinding(id.name)
+  if (!binding) {
+    return false
+  }
+  if (binding.references > 0) {
+    return false
+  }
+  if (binding.constantViolations.length > 0) {
+    return false
+  }
+  if (bindingReachableByEval(binding, evalReachableScopes)) {
+    return false
+  }
+
+  if (path.node.init) {
+    dereferenceSubtree(path.get('init') as NodePath)
+  }
+  path.scope.removeBinding(id.name)
+  path.remove()
+  if (declaration.node && declaration.node.declarations.length === 0) {
+    declaration.remove()
+  }
+  return true
+}
+
+function tryRemoveFunctionDecl(
+  path: NodePath<t.FunctionDeclaration>,
+  evalReachableScopes: Set<t.Node>,
+): 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
+  if (!id) {
+    return false
+  }
+
+  const binding = path.scope.getBinding(id.name)
+  if (!binding) {
+    return false
+  }
+  if (binding.references > 0) {
+    return false
+  }
+  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 {
+  if (isExported(path)) {
+    return false
+  }
+  const { id } = path.node
+  if (!id) {
+    return false
+  }
+
+  // `extends`, computed keys, static fields, and static blocks run on evaluation.
+  if (path.node.superClass && !isSideEffectFree(path.node.superClass, path.scope, path)) {
+    return false
+  }
+  for (const member of path.node.body.body) {
+    // Public and private static fields have different Babel node types.
+    if ((t.isClassProperty(member) || t.isClassPrivateProperty(member)) && member.static) {
+      return false
+    }
+    if (t.isStaticBlock(member)) {
+      return false
+    }
+    if (
+      'computed' in member &&
+      member.computed &&
+      'key' in member &&
+      !isSideEffectFree(member.key, path.scope, path)
+    ) {
+      return false
+    }
+  }
+
+  const binding = path.scope.getBinding(id.name)
+  if (!binding) {
+    return false
+  }
+  if (binding.references > 0) {
+    return false
+  }
+  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)
+  }
+  path.scope.removeBinding(id.name)
+  path.remove()
+  return true
+}
+
+function tryRemoveExpressionStatement(path: NodePath<t.ExpressionStatement>): boolean {
+  if (!isSideEffectFree(path.node.expression, path.scope, path.get('expression'))) {
+    return false
+  }
+  dereferenceSubtree(path.get('expression') as NodePath)
+  path.remove()
+  return true
+}
+
+function isExported(path: NodePath): boolean {
+  const parent = path.parentPath
+  if (!parent) {
+    return false
+  }
+  return parent.isExportNamedDeclaration() || parent.isExportDefaultDeclaration()
+}