webfuscator 1.3.0 → 1.3.1

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
-}