webfuscator 1.3.0 → 1.3.2

package/src/transforms/pack.ts

@@ -5,7 +5,6 @@ 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'
@@ -108,17 +107,10 @@ const STANDARD_GLOBALS: readonly string[] = [
 ]
 
 /**
- * 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. Imports remain above the call. Names inside
- * `with` stay bare so the object still controls lookup. A Function body cannot
- * contain exports, so pack throws when it finds one. Code that needs
- * `import.meta`, top-level await, dynamic `import()`, or top-level `arguments`
- * will not run after the move.
+ * Serializes the whole program and runs it through the `Function` constructor.
+ * Imports stay outside the generated function. Reads and writes to other free
+ * names go through accessors created in the original top-level scope. Export
+ * statements are rejected because they cannot appear in a `Function` body.
  *
  * @example
  * // ◀️ before
@@ -233,11 +225,6 @@ function packProgram(programPath: NodePath<t.Program>, ctx: TransformContext): b
     if (name === objectName || name === 'arguments') {
       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
     }

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

@@ -5,7 +5,6 @@ import type { File } from '@babel/types'
 
 import { isSideEffectFree } from '../analysis/purity'
 import type { ChangeState } from '../utils/change-tracking'
-import { hasAnnexBFunctionAlias } from '../utils/paths'
 
 /**
  * Removes unused declarations and expression statements that have no effects.
@@ -119,7 +118,7 @@ function tryRemoveDeclarator(path: NodePath<t.VariableDeclarator>): boolean {
   }
 
   const init = path.node.init
-  if (init && !isSideEffectFree(init, path.scope, path.get('init') as NodePath)) {
+  if (init && !isSideEffectFree(init, path.scope)) {
     return false
   }
 
@@ -130,7 +129,7 @@ function tryRemoveDeclarator(path: NodePath<t.VariableDeclarator>): boolean {
   if (binding.references > 0) {
     return false
   }
-  if (binding.constantViolations.length > 0) {
+  if (declaration.node.kind !== 'const' && binding.constantViolations.length > 0) {
     return false
   }
   if (path.node.init) {
@@ -148,10 +147,6 @@ 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
@@ -183,7 +178,7 @@ function tryRemoveClassDecl(path: NodePath<t.ClassDeclaration>): boolean {
   }
 
   // `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) {
@@ -198,7 +193,7 @@ function tryRemoveClassDecl(path: NodePath<t.ClassDeclaration>): boolean {
       'computed' in member &&
       member.computed &&
       'key' in member &&
-      !isSideEffectFree(member.key, path.scope, path)
+      !isSideEffectFree(member.key, path.scope)
     ) {
       return false
     }
@@ -224,7 +219,7 @@ function tryRemoveClassDecl(path: NodePath<t.ClassDeclaration>): boolean {
 }
 
 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 { 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
@@ -48,7 +47,6 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
   const liveAncestors = new Map<Scope, Set<Binding>>()
   // Reserve unbound names so generated bindings cannot capture them.
   const freeNames = new Set<string>()
-  // A reference inside `with` pins its binding to the source name.
   const unrenamable = new Set<Binding>()
   // Reserve pinned source names globally, including before their binding is seen.
   const pinnedNames = new Set<string>()
@@ -69,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)
@@ -83,17 +78,6 @@ export function renameIdentifiers(ast: File, ctx: TransformContext): boolean {
         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.

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

@@ -2,14 +2,12 @@ import type { NodePath } from '@babel/traverse'
 import type * as t from '@babel/types'
 import type { File } from '@babel/types'
 
-import { hasAnnexBFunctionAlias } from '../utils/paths'
 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,
- * and leaves sloppy Annex B block functions in place.
+ * 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.
@@ -76,5 +74,5 @@ function createsDirective(statements: readonly t.Statement[]): boolean {
 }
 
 function isMovable(child: NodePath<t.Statement>): boolean {
-  return child.isFunctionDeclaration() && child.node.id !== null && !hasAnnexBFunctionAlias(child)
+  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 { isInsideWith } from '../utils/ast'
 import type { ChangeState } from '../utils/change-tracking'
 import { mulberry32 } from '../utils/random'
 import { StringGenerator } from '../utils/string-generator'
@@ -69,9 +68,8 @@ const visitor: Visitor<State> = {
     if (path.scope.getBinding(name)) {
       return
     }
-    // A replacement cannot occupy a write target. `with` may also shadow `NaN`,
-    // `Infinity`, or `undefined`.
-    if (isWriteTarget(path) || isInsideWith(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)),

package/src/transforms/update-to-assignment.ts

@@ -2,7 +2,6 @@ import type { Binding, 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'
 
@@ -44,10 +43,6 @@ const visitor: Visitor<ChangeState> = {
     if (!prefix && !valueIsDiscarded(path)) {
       return
     }
-    // `with` can retarget the name and defeat the numeric proof.
-    if (isInsideWith(path)) {
-      return
-    }
     const binding = path.scope.getBinding(argument.name)
     if (!isNumericBinding(binding)) {
       return
@@ -75,19 +70,22 @@ function valueIsDiscarded(path: NodePath<t.UpdateExpression>): boolean {
   return false
 }
 
-// The initializer and every mutation must keep the binding numeric.
+// Mutable bindings must stay numeric. A const write cannot change its value.
 function isNumericBinding(binding: Binding | undefined): boolean {
-  if (!binding || (binding.kind !== 'var' && binding.kind !== 'let')) {
+  if (!binding || (binding.kind !== 'var' && binding.kind !== 'let' && binding.kind !== 'const')) {
     return false
   }
   const declarator = binding.path.node
   if (!t.isVariableDeclarator(declarator) || !t.isNumericLiteral(declarator.init)) {
     return false
   }
-  // Babel misses the string writes from an Annex B `for-in` initializer.
+  // Babel does not record each value assigned by a `for-in` or `for-of` head.
   if (isForInOfLoopVariable(binding)) {
     return false
   }
+  if (binding.kind === 'const') {
+    return true
+  }
   return binding.constantViolations.every((violation) => keepsNumeric(violation.node))
 }
 

package/src/transforms/yodify-conditions.ts

@@ -7,10 +7,9 @@ import type { ChangeState } from '../utils/change-tracking'
 import { isLiteralShaped } from '../utils/literal'
 
 /**
- * Moves a safe literal-shaped right operand to the left of a comparison.
- * Relational operators are flipped after swapping.
- *
- * Unary operations over literals also count when their coercion cannot act.
+ * Moves a right operand made from literals and unary operators to the left of a
+ * comparison when swapping does not change coercion order. Relational operators
+ * are flipped after swapping.
  *
  * @example
  * // ◀️ before

package/src/utils/ast.ts

@@ -69,32 +69,3 @@ export function isNonComputedKey(path: NodePath): boolean {
     'key' in parent && parent.key === path.node && 'computed' in parent && parent.computed === false
   )
 }
-
-// `with` can shadow names outside Babel's scope table.
-export function isInsideWith(path: NodePath): boolean {
-  if (!programHasWith(path.scope.getProgramParent().block)) {
-    return false
-  }
-  return path.findParent((ancestor) => ancestor.isWithStatement()) !== null
-}
-
-// Cache the program-wide scan because `isInsideWith` runs for many identifiers.
-// Transforms never add `with`, so a cached miss remains valid.
-const programWith = new WeakMap<t.Node, boolean>()
-
-function programHasWith(programNode: t.Node): boolean {
-  const cached = programWith.get(programNode)
-  if (cached !== undefined) {
-    return cached
-  }
-  let found = false
-  t.traverseFast(programNode, (node) => {
-    if (!t.isWithStatement(node)) {
-      return
-    }
-    found = true
-    return t.traverseFast.stop
-  })
-  programWith.set(programNode, found)
-  return found
-}

package/src/utils/evaluation-order.ts

@@ -133,7 +133,7 @@ function precedingSiblings<T extends NodePath>(
 }
 
 function isPurePath(path: NodePath): boolean {
-  return isPure(path.node, path.scope, path)
+  return isPure(path.node, path.scope)
 }
 
 function impure(paths: (NodePath | null | undefined)[]): boolean {

package/src/utils/logical-lowering.ts

@@ -9,7 +9,7 @@ import { isStandaloneDeclaration } from './paths'
 //   x = L;
 //   if (<fallbackTest(x)>) x = R;
 //
-// `fallbackTest` selects `!x`, `x`, or `x == null`. The parent must accept a
+// `fallbackTest` selects the short-circuit condition. The parent must accept a
 // multi-statement replacement.
 export function lowerLogicalWriteStatement(
   path: NodePath<t.LogicalExpression>,
@@ -29,21 +29,20 @@ export function lowerLogicalWriteStatement(
     const declStmt = parent.parentPath
     if (
       !declStmt?.isVariableDeclaration() ||
-      // The split would emit illegal `const x;` and then write it.
-      declStmt.node.kind === 'const' ||
       declStmt.node.declarations.length !== 1 ||
       !isStandaloneDeclaration(declStmt)
     ) {
       return false
     }
     const target = parent.node.id
-    // The split writes `x` before evaluating the right side. Refuse any right
-    // side that could observe the new value or the ended TDZ.
-    if (rightCanObserveTarget(node.right, target.name)) {
+    // A `var` initializer can observe its previous value while evaluating the
+    // right side. Reads before lexical initialization are intentionally ignored.
+    if (declStmt.node.kind === 'var' && rightCanObserveTarget(node.right, target.name)) {
       return false
     }
+    const declarationKind = declStmt.node.kind === 'const' ? 'let' : declStmt.node.kind
     declStmt.replaceWithMultiple([
-      t.variableDeclaration(declStmt.node.kind, [
+      t.variableDeclaration(declarationKind, [
         t.variableDeclarator(t.cloneNode(target), node.left),
       ]),
       guardedReassignment(target, fallbackTest, node.right),
@@ -68,10 +67,7 @@ export function lowerLogicalWriteStatement(
       return false
     }
     // Writing first would change `x = 0 || x` before the right side reads `x`.
-    if (
-      !isSideEffectFree(node.right, path.scope, path) ||
-      referencesName(node.right, target.name)
-    ) {
+    if (!isSideEffectFree(node.right, path.scope) || referencesName(node.right, target.name)) {
       return false
     }
     exprStmt.replaceWithMultiple([

package/src/utils/nullish.ts

@@ -0,0 +1,23 @@
+import * as t from '@babel/types'
+
+export function buildNullishCheck(
+  firstRead: t.Expression,
+  secondRead: t.Expression,
+): t.ConditionalExpression {
+  return t.conditionalExpression(
+    t.binaryExpression('===', firstRead, t.nullLiteral()),
+    t.booleanLiteral(true),
+    t.binaryExpression('===', secondRead, t.unaryExpression('void', t.numericLiteral(0))),
+  )
+}
+
+export function buildNonNullishCheck(
+  firstRead: t.Expression,
+  secondRead: t.Expression,
+): t.ConditionalExpression {
+  return t.conditionalExpression(
+    t.binaryExpression('!==', firstRead, t.nullLiteral()),
+    t.binaryExpression('!==', secondRead, t.unaryExpression('void', t.numericLiteral(0))),
+    t.booleanLiteral(false),
+  )
+}

package/src/utils/paths.ts

@@ -69,35 +69,3 @@ export function isInStrictContext(path: NodePath): boolean {
 function hasUseStrictDirective(directives: readonly t.Directive[]): boolean {
   return directives.some((directive) => directive.value.value === 'use strict')
 }
-
-// ECMA-262 B.3.3 gives sloppy block-level functions a `var` alias that Babel
-// omits from the enclosing scope. Renaming, moving, or removing one can expose it.
-export function hasAnnexBFunctionAlias(path: NodePath): boolean {
-  if (!path.isFunctionDeclaration()) {
-    return false
-  }
-  const parent = path.parentPath
-  if (!parent || parent.isProgram()) {
-    return false
-  }
-  if (
-    parent.isBlockStatement() &&
-    parent.key === 'body' &&
-    parent.parentPath != null &&
-    parent.parentPath.isFunction()
-  ) {
-    return false
-  }
-  return !isInStrictContext(parent)
-}
-
-// A later write to `const` must keep throwing after transformation.
-export function hasConstantViolation(path: NodePath<t.VariableDeclaration>): boolean {
-  for (const name of Object.keys(path.getBindingIdentifiers())) {
-    const binding = path.scope.getBinding(name)
-    if (binding && binding.constantViolations.length > 0) {
-      return true
-    }
-  }
-  return false
-}