webfuscator 1.3.2 → 1.3.3

package/src/transforms/fold-constants.ts

@@ -10,8 +10,8 @@ import { valueToLiteral } from '../utils/literal'
 import { isCalleeOrTagOf } from '../utils/paths'
 
 /**
- * Folds pure constant expressions to literals via `evaluateConstant`.
- * Logical and conditional nodes can fold directly to a chosen nonliteral branch.
+ * Replaces pure compile-time constant expressions with equivalent literals or
+ * selected branches.
  *
  * @example
  * // ◀️ before

package/src/transforms/for-to-while.ts

@@ -7,9 +7,8 @@ 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
- * become breaks from an inner block so the update still runs. Iterator loops
- * stay unchanged.
+ * Rewrites classic `for` loops as equivalent `while` loops. `for...in` and
+ * `for...of` loops stay unchanged.
  *
  * @example
  * // ◀️ before

package/src/transforms/function-declaration-to-expression.ts

@@ -6,13 +6,9 @@ import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
 /**
- * Rewrites function declarations at script top level or directly inside a
- * function body as `var` initializers. It leaves a declaration unchanged when
- * an earlier statement could execute user code before the assignment.
- *
- * Name inference and recursive references still use the `var` binding.
- *
- * Block-level and module top-level declarations stay unchanged.
+ * Rewrites eligible function declarations in scripts and function bodies as
+ * `var`-initialized function expressions. Declarations stay unchanged when
+ * moving initialization to their statement position could alter execution.
  *
  * @example
  * // ◀️ before

package/src/transforms/hoist-variables.ts

@@ -6,10 +6,8 @@ import type { File } from '@babel/types'
 import type { ChangeState } from '../utils/change-tracking'
 
 /**
- * Moves `var` declarations to the start of their var scope without moving
- * initializer evaluation.
- *
- * Direct exports stay in place. Static blocks keep separate declarations.
+ * Moves `var` declarations to the beginning of their containing function or
+ * program without moving initializer evaluation.
  *
  * @example
  * // ◀️ before

package/src/transforms/inline-functions.ts

@@ -12,8 +12,8 @@ import { generateLoopLabel } from '../utils/loop-lowering'
 import { isInStrictContext } from '../utils/paths'
 
 /**
- * Replaces eligible calls with function bodies, working from inner calls out.
- * Declarations are removed after their last reference disappears.
+ * Replaces eligible function calls with the called function's body and removes
+ * declarations that become unused.
  *
  * @example
  * // ◀️ before

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

@@ -9,8 +9,8 @@ import { lowerLogicalWriteStatement } from '../utils/logical-lowering'
 import { buildNonNullishCheck, buildNullishCheck } from '../utils/nullish'
 
 /**
- * Rewrites logical expressions as guarded assignments or ternaries. A
- * side-effectful left side is cached in the ternary test for later hoisting.
+ * Rewrites logical expressions as equivalent conditional expressions or
+ * guarded assignments while preserving short-circuit evaluation.
  *
  * @example
  * // ◀️ before

package/src/transforms/mangle-properties.ts

@@ -12,9 +12,8 @@ import { mulberry32 } from '../utils/random'
 import { StringGenerator } from '../utils/string-generator'
 
 /**
- * Renames statically known public properties through one program-wide mapping.
- * Options select or reserve names, and collision checks keep every unchanged
- * property distinct from the generated names.
+ * Renames statically known public properties using one consistent program-wide
+ * mapping.
  *
  * @example
  * // ◀️ before

package/src/transforms/merge-variable-declarations.ts

@@ -4,9 +4,7 @@ import type { File } from '@babel/types'
 import { rewriteStatementLists } from '../utils/statement-lists'
 
 /**
- * Merges adjacent variable declarations when their kinds and export wrappers
- * match. It runs in programs, blocks, switch cases, and static blocks, and
- * removes unlabeled empty statements between compatible declarations.
+ * Merges adjacent compatible variable declarations into a single declaration.
  *
  * @example
  * // ◀️ before

package/src/transforms/nullish-coalescing-to-ternary.ts

@@ -8,8 +8,8 @@ import { lowerLogicalWriteStatement } from '../utils/logical-lowering'
 import { buildNonNullishCheck, buildNullishCheck } from '../utils/nullish'
 
 /**
- * Rewrites `a ?? b` as a guarded assignment or strict null and undefined
- * checks. A side-effectful left side is cached.
+ * Rewrites nullish-coalescing expressions as equivalent conditional expressions
+ * while evaluating the left operand once.
  *
  * @example
  * // ◀️ before

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

@@ -7,11 +7,7 @@ import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
 /**
- * Rewrites numeric literals as strings coerced with unary plus. Under `+`, `-`,
- * or `~`, the existing operator supplies that coercion. Other unary operators
- * keep the wrapper because their string behavior differs.
- *
- * Preparation has already converted numeric object keys to strings.
+ * Rewrites numeric literals as equivalent string-coercion expressions.
  *
  * @example
  * // ◀️ before

package/src/transforms/object-method-to-property.ts

@@ -7,16 +7,8 @@ import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
 /**
- * Rewrites generator and async object methods as function-valued properties so
- * later passes can lift and inline them.
- *
- * Plain methods stay concise because a function property would gain construction
- * and `prototype`. Generator and async functions remain non-constructors. Any
- * method using `super` also stays intact because a function has no HomeObject.
- *
- * Non-computed `__proto__` methods stay intact because the property form invokes
- * ECMA-262 B.3.1 prototype-setting behavior. Computed keys create own properties
- * and can be rewritten.
+ * Rewrites eligible async and generator object methods as function-valued
+ * properties.
  *
  * @example
  * // ◀️ before

package/src/transforms/optional-chaining-to-ternary.ts

@@ -7,9 +7,8 @@ import type { ChangeState } from '../utils/change-tracking'
 import { buildNullishCheck } from '../utils/nullish'
 
 /**
- * Rewrites optional chains as nested ternaries. Side-effectful receivers are
- * cached, and member calls retain their `this`. Optional deletion short-circuits
- * to `true` as required by ECMA-262 13.5.1.
+ * Rewrites optional chains as equivalent conditional expressions while
+ * preserving short-circuiting and method receivers.
  *
  * @example
  * // ◀️ before

package/src/transforms/pack-declarations-into-parameters.ts

@@ -8,11 +8,8 @@ import type { ChangeState } from '../utils/change-tracking'
 import { isLiteralShaped } from '../utils/literal'
 
 /**
- * Moves leading literal-valued `var` declarations into trailing default
- * parameters. Arrows, rest parameters, name collisions, and functions with
- * callers that could fill a new slot stay unchanged.
- *
- * Packing also requires unchanged `arguments`, directive, and hoisting behavior.
+ * Moves eligible leading `var` declarations with literal initializers into
+ * trailing default parameters.
  *
  * @example
  * // ◀️ before

package/src/transforms/pack-expressions.ts

@@ -0,0 +1,159 @@
+import * as t from '@babel/types'
+import type { File } from '@babel/types'
+
+import { rewriteStatementLists } from '../utils/statement-lists'
+
+/**
+ * Combines adjacent expression statements with the comma operator and moves
+ * them into a following compatible statement when execution order is preserved.
+ *
+ * @example
+ * // ◀️ before
+ * function run() {
+ *   prepare();
+ *   update();
+ *   return finish();
+ * }
+ *
+ * // ▶️ after
+ * function run() {
+ *   return prepare(), update(), finish();
+ * }
+ */
+export function packExpressions(ast: File): boolean {
+  return rewriteStatementLists(ast, (statements) =>
+    packStatementList(statements.map((path) => path.node)),
+  )
+}
+
+type StatementLike = t.Program['body'][number]
+
+function packStatementList(list: readonly StatementLike[]): StatementLike[] | null {
+  const out: StatementLike[] = []
+  let pending: t.ExpressionStatement[] = []
+  let changed = false
+
+  const flush = (): void => {
+    if (pending.length === 1) {
+      out.push(pending[0]!)
+    } else if (pending.length > 1) {
+      out.push(
+        t.expressionStatement(
+          expressionFrom(
+            flattenExpressions(pending.map((pendingStatement) => pendingStatement.expression)),
+          ),
+        ),
+      )
+      changed = true
+    }
+    pending = []
+  }
+
+  for (const statement of list) {
+    if (t.isExpressionStatement(statement)) {
+      pending.push(statement)
+      continue
+    }
+
+    if (pending.length > 0) {
+      const expressions = flattenExpressions(
+        pending.map((pendingStatement) => pendingStatement.expression),
+      )
+      if (prependToConsumer(statement, expressions)) {
+        out.push(statement)
+        pending = []
+        changed = true
+        continue
+      }
+    }
+
+    flush()
+    out.push(statement)
+  }
+
+  flush()
+  return changed ? out : null
+}
+
+function prependToConsumer(statement: StatementLike, expressions: t.Expression[]): boolean {
+  if (t.isReturnStatement(statement)) {
+    const argument = statement.argument ?? t.unaryExpression('void', t.numericLiteral(0))
+    statement.argument = prependExpressions(expressions, argument)
+    return true
+  }
+  if (t.isThrowStatement(statement)) {
+    statement.argument = prependExpressions(expressions, statement.argument)
+    return true
+  }
+  if (t.isIfStatement(statement)) {
+    statement.test = prependExpressions(expressions, statement.test)
+    return true
+  }
+  if (t.isSwitchStatement(statement)) {
+    statement.discriminant = prependExpressions(expressions, statement.discriminant)
+    return true
+  }
+  if (t.isWithStatement(statement)) {
+    statement.object = prependExpressions(expressions, statement.object)
+    return true
+  }
+  if (t.isForStatement(statement)) {
+    if (t.isVariableDeclaration(statement.init)) {
+      return false
+    }
+    statement.init = statement.init
+      ? prependExpressions(expressions, statement.init)
+      : expressionFrom(expressions)
+    return true
+  }
+  if (t.isForInStatement(statement) || t.isForOfStatement(statement)) {
+    if (!canPrependToForXRight(statement.left)) {
+      return false
+    }
+    statement.right = prependExpressions(expressions, statement.right)
+    return true
+  }
+  return false
+}
+
+function canPrependToForXRight(left: t.ForInStatement['left']): boolean {
+  if (!t.isVariableDeclaration(left)) {
+    return true
+  }
+  // A lexical loop head is active while the right side runs; a preceding
+  // statement is outside it. A legacy var initializer also runs before the
+  // right side.
+  return left.kind === 'var' && left.declarations.every((declaration) => !declaration.init)
+}
+
+function flattenExpressions(input: readonly t.Expression[]): t.Expression[] {
+  const remaining: t.Expression[] = []
+  for (let index = input.length - 1; index >= 0; index--) {
+    remaining.push(input[index]!)
+  }
+
+  const expressions: t.Expression[] = []
+  while (remaining.length > 0) {
+    const expression = remaining.pop()!
+    if (t.isSequenceExpression(expression)) {
+      for (let index = expression.expressions.length - 1; index >= 0; index--) {
+        remaining.push(expression.expressions[index]!)
+      }
+    } else {
+      expressions.push(expression)
+    }
+  }
+  return expressions
+}
+
+function prependExpressions(
+  expressions: readonly t.Expression[],
+  consumer: t.Expression,
+): t.Expression {
+  const flattenedConsumer = flattenExpressions([consumer])
+  return expressionFrom([...expressions, ...flattenedConsumer])
+}
+
+function expressionFrom(expressions: t.Expression[]): t.Expression {
+  return expressions.length === 1 ? expressions[0]! : t.sequenceExpression(expressions)
+}

package/src/transforms/pack.ts

@@ -107,10 +107,8 @@ const STANDARD_GLOBALS: readonly string[] = [
 ]
 
 /**
- * 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.
+ * Serializes the program and executes it through a generated `Function`
+ * constructor.
  *
  * @example
  * // ◀️ before

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

@@ -6,10 +6,8 @@ import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../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.
+ * Removes unreachable statements that follow unconditional control flow while
+ * retaining declarations whose hoisting can still be observed.
  *
  * @example
  * // ◀️ before

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

@@ -7,8 +7,8 @@ import { isSideEffectFree } from '../analysis/purity'
 import type { ChangeState } from '../utils/change-tracking'
 
 /**
- * Removes unused declarations and expression statements that have no effects.
- * Sweeps continue because each removal can strand another binding.
+ * Removes unused declarations and side-effect-free expression statements until
+ * no further code becomes unused.
  *
  * @example
  * // ◀️ before

package/src/transforms/rename-identifiers.ts

@@ -9,9 +9,8 @@ import { mulberry32 } from '../utils/random'
 import { StringGenerator } from '../utils/string-generator'
 
 /**
- * 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.
+ * Renames bindings and labels with the configured string generator while
+ * avoiding name capture.
  *
  * @example
  * // ◀️ before

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

@@ -6,12 +6,8 @@ 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.
+ * Moves hoisted function declarations to the end of their statement lists
+ * without changing their relative order.
  *
  * @example
  * // ◀️ before

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

@@ -9,19 +9,8 @@ import { mulberry32 } from '../utils/random'
 import { StringGenerator } from '../utils/string-generator'
 
 /**
- * Rewrites five constant-like values through strings for later string mangling:
- *
- *   - `true`     -> `!!"<random>"`
- *   - `false`    -> `!"<random>"`
- *   - `NaN`      -> `+"<random>"`
- *   - `undefined`-> `void "<random>"`
- *   - `Infinity` -> `1/!"<random>"`
- *
- * Generated strings are nonempty and nonnumeric, fixing their truthiness and
- * numeric coercion.
- *
- * `NaN`, `Infinity`, and `undefined` require genuine global reads. Delete and
- * write positions stay unchanged because the replacement is not a reference.
+ * Rewrites `true`, `false`, `NaN`, `undefined`, and `Infinity` as equivalent
+ * expressions built from strings.
  *
  * @example
  * // ◀️ before

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

@@ -9,10 +9,9 @@ import { isPrimitiveLiteral } from '../utils/literal'
 import { generateLoopLabel } from '../utils/loop-lowering'
 
 /**
- * Lowers `switch` to an `if` chain or, when cases fall through, a labeled block
- * with a fallthrough flag. Case tests keep source order and evaluation count.
- * Cases with lexical or function declarations stay unchanged because separate
- * `if` blocks cannot preserve the shared switch scope.
+ * Rewrites eligible `switch` statements as equivalent `if` statements, using a
+ * labeled block when fallthrough must be preserved. Switches whose shared case
+ * scope cannot be preserved stay unchanged.
  *
  * @example
  * // ◀️ before

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

@@ -8,9 +8,8 @@ import { isConditionalGate, reorderableToStatement } from '../utils/evaluation-o
 import { isStandaloneDeclaration } from '../utils/paths'
 
 /**
- * Lowers conditional expressions to `if` statements. Expression values use a
- * temporary. Parameter defaults and repeating loop tests stay unchanged because
- * hoisting would change when they run.
+ * Rewrites eligible conditional expressions as `if` statements, using a
+ * temporary when their value is needed.
  *
  * @example
  * // ◀️ before

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

@@ -6,12 +6,8 @@ import { traverseForChanges } from '../utils/change-tracking'
 import type { ChangeState } from '../utils/change-tracking'
 
 /**
- * Rewrites numeric updates as compound assignments for later expansion. Prefix
- * results already match. Postfix forms require a position that discards the old
- * value.
- *
- * BigInt differs because adding the number `1` throws. Only bindings proven to
- * stay numeric are rewritten. Members and parameters stay unchanged.
+ * Rewrites eligible numeric update expressions as compound assignments. Postfix
+ * updates stay unchanged when their original value is used.
  *
  * @example
  * // ◀️ before

package/src/transforms/yodify-conditions.ts

@@ -7,9 +7,8 @@ import type { ChangeState } from '../utils/change-tracking'
 import { isLiteralShaped } from '../utils/literal'
 
 /**
- * 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.
+ * Moves eligible literal-like right operands to the left side of comparisons,
+ * reversing relational operators as needed.
  *
  * @example
  * // ◀️ before