littlewing 0.5.2 → 0.6.0

package/dist/index.js

@@ -15,8 +15,8 @@ var exports_ast = {};
 __export(exports_ast, {
   unaryOp: () => unaryOp,
   subtract: () => subtract,
+  program: () => program,
   number: () => number,
-  nullishAssign: () => nullishAssign,
   notEquals: () => notEquals,
   negate: () => negate,
   multiply: () => multiply,
@@ -37,6 +37,12 @@ __export(exports_ast, {
   assign: () => assign,
   add: () => add
 });
+function program(statements) {
+  return {
+    type: "Program",
+    statements
+  };
+}
 function number(value) {
   return {
     type: "NumberLiteral",
@@ -78,13 +84,6 @@ function assign(name, value) {
     value
   };
 }
-function nullishAssign(name, value) {
-  return {
-    type: "NullishAssignment",
-    name,
-    value
-  };
-}
 function conditional(condition, consequent, alternate) {
   return {
     type: "ConditionalExpression",
@@ -163,7 +162,6 @@ var TokenType;
   TokenType2["COMMA"] = "COMMA";
   TokenType2["QUESTION"] = "QUESTION";
   TokenType2["COLON"] = "COLON";
-  TokenType2["NULLISH_ASSIGN"] = "NULLISH_ASSIGN";
   TokenType2["EOF"] = "EOF";
 })(TokenType ||= {});
 function isNumberLiteral(node) {
@@ -190,9 +188,6 @@ function isProgram(node) {
 function isConditionalExpression(node) {
   return node.type === "ConditionalExpression";
 }
-function isNullishAssignment(node) {
-  return node.type === "NullishAssignment";
-}
 
 // src/utils.ts
 function evaluateBinaryOperation(operator, left, right) {
@@ -264,7 +259,6 @@ function getOperatorPrecedence(operator) {
 function getTokenPrecedence(type) {
   switch (type) {
     case "EQUALS" /* EQUALS */:
-    case "NULLISH_ASSIGN" /* NULLISH_ASSIGN */:
       return 1;
     case "QUESTION" /* QUESTION */:
       return 2;
@@ -310,8 +304,6 @@ class CodeGenerator {
       return this.generateFunctionCall(node);
     if (isAssignment(node))
       return this.generateAssignment(node);
-    if (isNullishAssignment(node))
-      return this.generateNullishAssignment(node);
     if (isConditionalExpression(node))
       return this.generateConditionalExpression(node);
     throw new Error(`Unknown node type`);
@@ -348,10 +340,6 @@ class CodeGenerator {
     const value = this.generate(node.value);
     return `${node.name} = ${value}`;
   }
-  generateNullishAssignment(node) {
-    const value = this.generate(node.value);
-    return `${node.name} ??= ${value}`;
-  }
   generateConditionalExpression(node) {
     const condition = this.generate(node.condition);
     const consequent = this.generate(node.consequent);
@@ -422,8 +410,10 @@ var defaultContext = {
 class Lexer {
   source;
   position = 0;
+  length;
   constructor(source) {
     this.source = source;
+    this.length = source.length;
   }
   tokenize() {
     const tokens = [];
@@ -438,14 +428,23 @@ class Lexer {
   }
   nextToken() {
     this.skipWhitespaceAndComments();
-    if (this.position >= this.source.length) {
+    if (this.position >= this.length) {
+      return { type: "EOF" /* EOF */, value: "", position: this.position };
+    }
+    const char = this.source[this.position];
+    if (char === undefined) {
       return { type: "EOF" /* EOF */, value: "", position: this.position };
     }
-    const char = this.getCharAt(this.position);
     const start = this.position;
     if (this.isDigit(char)) {
       return this.readNumber();
     }
+    if (char === ".") {
+      const nextChar = this.source[this.position + 1];
+      if (nextChar !== undefined && this.isDigit(nextChar)) {
+        return this.readNumber();
+      }
+    }
     if (this.isLetter(char) || char === "_") {
       return this.readIdentifier();
     }
@@ -475,41 +474,33 @@ class Lexer {
         this.position++;
         return { type: "RPAREN" /* RPAREN */, value: ")", position: start };
       case "=":
-        if (this.peek() === "=") {
+        if (this.source[this.position + 1] === "=") {
           this.position += 2;
           return { type: "DOUBLE_EQUALS" /* DOUBLE_EQUALS */, value: "==", position: start };
         }
         this.position++;
         return { type: "EQUALS" /* EQUALS */, value: "=", position: start };
       case "!":
-        if (this.peek() === "=") {
+        if (this.source[this.position + 1] === "=") {
           this.position += 2;
           return { type: "NOT_EQUALS" /* NOT_EQUALS */, value: "!=", position: start };
         }
         throw new Error(`Unexpected character '${char}' at position ${start}`);
       case "<":
-        if (this.peek() === "=") {
+        if (this.source[this.position + 1] === "=") {
           this.position += 2;
           return { type: "LESS_EQUAL" /* LESS_EQUAL */, value: "<=", position: start };
         }
         this.position++;
         return { type: "LESS_THAN" /* LESS_THAN */, value: "<", position: start };
       case ">":
-        if (this.peek() === "=") {
+        if (this.source[this.position + 1] === "=") {
           this.position += 2;
           return { type: "GREATER_EQUAL" /* GREATER_EQUAL */, value: ">=", position: start };
         }
         this.position++;
         return { type: "GREATER_THAN" /* GREATER_THAN */, value: ">", position: start };
       case "?":
-        if (this.peek() === "?" && this.peekAhead(2) === "=") {
-          this.position += 3;
-          return {
-            type: "NULLISH_ASSIGN" /* NULLISH_ASSIGN */,
-            value: "??=",
-            position: start
-          };
-        }
         this.position++;
         return { type: "QUESTION" /* QUESTION */, value: "?", position: start };
       case ":":
@@ -522,13 +513,13 @@ class Lexer {
         this.position++;
         return this.nextToken();
       case "&":
-        if (this.peek() === "&") {
+        if (this.source[this.position + 1] === "&") {
           this.position += 2;
           return { type: "LOGICAL_AND" /* LOGICAL_AND */, value: "&&", position: start };
         }
         throw new Error(`Unexpected character '${char}' at position ${start}`);
       case "|":
-        if (this.peek() === "|") {
+        if (this.source[this.position + 1] === "|") {
           this.position += 2;
           return { type: "LOGICAL_OR" /* LOGICAL_OR */, value: "||", position: start };
         }
@@ -538,14 +529,15 @@ class Lexer {
     }
   }
   skipWhitespaceAndComments() {
-    while (this.position < this.source.length) {
-      const char = this.getCharAt(this.position);
+    while (this.position < this.length) {
+      const char = this.source[this.position];
       if (this.isWhitespace(char)) {
         this.position++;
         continue;
       }
-      if (char === "/" && this.peek() === "/") {
-        while (this.position < this.source.length && this.getCharAt(this.position) !== `
+      if (char === "/" && this.source[this.position + 1] === "/") {
+        this.position += 2;
+        while (this.position < this.length && this.source[this.position] !== `
 `) {
           this.position++;
         }
@@ -558,8 +550,12 @@ class Lexer {
     const start = this.position;
     let hasDecimal = false;
     let hasExponent = false;
-    while (this.position < this.source.length) {
-      const char = this.getCharAt(this.position);
+    if (this.source[this.position] === ".") {
+      hasDecimal = true;
+      this.position++;
+    }
+    while (this.position < this.length) {
+      const char = this.source[this.position];
       if (this.isDigit(char)) {
         this.position++;
       } else if (char === "." && !hasDecimal && !hasExponent) {
@@ -568,14 +564,15 @@ class Lexer {
       } else if ((char === "e" || char === "E") && !hasExponent) {
         hasExponent = true;
         this.position++;
-        const nextChar = this.getCharAt(this.position);
+        const nextChar = this.source[this.position];
         if (nextChar === "+" || nextChar === "-") {
           this.position++;
         }
-        if (!this.isDigit(this.getCharAt(this.position))) {
+        const digitChar = this.source[this.position];
+        if (digitChar === undefined || !this.isDigit(digitChar)) {
           throw new Error(`Invalid number: expected digit after exponent at position ${this.position}`);
         }
-        while (this.position < this.source.length && this.isDigit(this.getCharAt(this.position))) {
+        while (this.position < this.length && this.isDigit(this.source[this.position])) {
           this.position++;
         }
         break;
@@ -588,8 +585,8 @@ class Lexer {
   }
   readIdentifier() {
     const start = this.position;
-    while (this.position < this.source.length) {
-      const char = this.getCharAt(this.position);
+    while (this.position < this.length) {
+      const char = this.source[this.position];
       if (this.isLetter(char) || this.isDigit(char) || char === "_") {
         this.position++;
       } else {
@@ -599,24 +596,15 @@ class Lexer {
     const name = this.source.slice(start, this.position);
     return { type: "IDENTIFIER" /* IDENTIFIER */, value: name, position: start };
   }
-  getCharAt(pos) {
-    return pos < this.source.length ? this.source[pos] || "" : "";
-  }
-  peek() {
-    return this.getCharAt(this.position + 1);
-  }
-  peekAhead(n) {
-    return this.getCharAt(this.position + n);
-  }
   isDigit(char) {
-    return char >= "0" && char <= "9";
+    return char !== undefined && char >= "0" && char <= "9";
   }
   isLetter(char) {
-    return char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+    return char !== undefined && (char >= "a" && char <= "z" || char >= "A" && char <= "Z");
   }
   isWhitespace(char) {
-    return char === " " || char === "\t" || char === `
-` || char === "\r";
+    return char !== undefined && (char === " " || char === "\t" || char === `
+` || char === "\r");
   }
 }
 
@@ -653,16 +641,13 @@ class Parser {
       throw new Error("Empty program");
     }
     if (statements.length === 1) {
-      const stmt = statements[0];
-      if (stmt === undefined) {
-        throw new Error("Unexpected undefined statement");
+      const singleStatement = statements[0];
+      if (singleStatement === undefined) {
+        throw new Error("Unexpected empty statements array");
       }
-      return stmt;
+      return singleStatement;
     }
-    return {
-      type: "Program",
-      statements
-    };
+    return program(statements);
   }
   parseExpression(minPrecedence) {
     let left = this.parsePrefix();
@@ -679,23 +664,7 @@ class Parser {
         const identName = left.name;
         this.advance();
         const value = this.parseExpression(precedence);
-        left = {
-          type: "Assignment",
-          name: identName,
-          value
-        };
-      } else if (token.type === "NULLISH_ASSIGN" /* NULLISH_ASSIGN */) {
-        if (left.type !== "Identifier") {
-          throw new Error("Invalid assignment target");
-        }
-        const identName = left.name;
-        this.advance();
-        const value = this.parseExpression(precedence);
-        left = {
-          type: "NullishAssignment",
-          name: identName,
-          value
-        };
+        left = assign(identName, value);
       } else if (token.type === "QUESTION" /* QUESTION */) {
         this.advance();
         const consequent = this.parseExpression(0);
@@ -704,22 +673,12 @@ class Parser {
         }
         this.advance();
         const alternate = this.parseExpression(precedence);
-        left = {
-          type: "ConditionalExpression",
-          condition: left,
-          consequent,
-          alternate
-        };
+        left = conditional(left, consequent, alternate);
       } else if (this.isBinaryOperator(token.type)) {
         const operator = token.value;
         this.advance();
         const right = this.parseExpression(precedence + 1);
-        left = {
-          type: "BinaryOp",
-          left,
-          operator,
-          right
-        };
+        left = binaryOp(left, operator, right);
       } else {
         break;
       }
@@ -731,11 +690,7 @@ class Parser {
     if (token.type === "MINUS" /* MINUS */) {
       this.advance();
       const argument = this.parseExpression(this.getUnaryPrecedence());
-      return {
-        type: "UnaryOp",
-        operator: "-",
-        argument
-      };
+      return unaryOp(argument);
     }
     if (token.type === "LPAREN" /* LPAREN */) {
       this.advance();
@@ -748,10 +703,7 @@ class Parser {
     }
     if (token.type === "NUMBER" /* NUMBER */) {
       this.advance();
-      return {
-        type: "NumberLiteral",
-        value: token.value
-      };
+      return number(token.value);
     }
     if (token.type === "IDENTIFIER" /* IDENTIFIER */) {
       const name = token.value;
@@ -763,16 +715,9 @@ class Parser {
           throw new Error("Expected closing parenthesis");
         }
         this.advance();
-        return {
-          type: "FunctionCall",
-          name,
-          arguments: args
-        };
+        return functionCall(name, args);
       }
-      return {
-        type: "Identifier",
-        name
-      };
+      return identifier(name);
     }
     throw new Error(`Unexpected token: ${token.value}`);
   }
@@ -819,9 +764,11 @@ function parseSource(source) {
 class Executor {
   context;
   variables;
+  externalVariables;
   constructor(context = {}) {
     this.context = context;
     this.variables = new Map(Object.entries(context.variables || {}));
+    this.externalVariables = new Set(Object.keys(context.variables || {}));
   }
   execute(node) {
     if (isProgram(node))
@@ -838,8 +785,6 @@ class Executor {
       return this.executeFunctionCall(node);
     if (isAssignment(node))
       return this.executeAssignment(node);
-    if (isNullishAssignment(node))
-      return this.executeNullishAssignment(node);
     if (isConditionalExpression(node))
       return this.executeConditionalExpression(node);
     throw new Error(`Unknown node type`);
@@ -885,13 +830,11 @@ class Executor {
     return fn(...args);
   }
   executeAssignment(node) {
-    const value = this.execute(node.value);
-    this.variables.set(node.name, value);
-    return value;
-  }
-  executeNullishAssignment(node) {
-    if (this.variables.has(node.name)) {
-      return this.variables.get(node.name);
+    if (this.externalVariables.has(node.name)) {
+      const externalValue = this.variables.get(node.name);
+      if (externalValue !== undefined) {
+        return externalValue;
+      }
     }
     const value = this.execute(node.value);
     this.variables.set(node.name, value);
@@ -909,420 +852,47 @@ function execute(source, context) {
 }
 // src/optimizer.ts
 function optimize(node) {
-  if (!isProgram(node)) {
-    return basicOptimize(node);
-  }
-  const analysis = analyzeProgram(node);
-  const { propagated, allConstants } = propagateConstantsOptimal(node, analysis);
-  const optimized = eliminateDeadCodeOptimal(propagated, analysis, allConstants);
-  return optimized;
-}
-function analyzeProgram(node) {
-  if (!isProgram(node)) {
-    return {
-      constants: new Map,
-      tainted: new Set,
-      dependencies: new Map,
-      liveVariables: new Set,
-      assignmentIndices: new Map,
-      evaluationOrder: []
-    };
-  }
-  const constants = new Map;
-  const tainted = new Set;
-  const dependencies = new Map;
-  const assignmentIndices = new Map;
-  const assignmentCounts = new Map;
-  for (let i = 0;i < node.statements.length; i++) {
-    const stmt = node.statements[i];
-    if (!stmt)
-      continue;
-    if (isAssignment(stmt) || isNullishAssignment(stmt)) {
-      const varName = stmt.name;
-      const count = assignmentCounts.get(varName) || 0;
-      assignmentCounts.set(varName, count + 1);
-      assignmentIndices.set(varName, i);
-      const deps = new Set;
-      const hasFunctionCall = collectDependencies(stmt.value, deps);
-      dependencies.set(varName, deps);
-      if (isNullishAssignment(stmt)) {
-        tainted.add(varName);
-      } else {
-        if (count === 0 && isNumberLiteral(stmt.value)) {
-          constants.set(varName, stmt.value.value);
-        }
-        if (hasFunctionCall) {
-          tainted.add(varName);
-        }
-      }
-    }
-  }
-  for (const [varName, count] of assignmentCounts) {
-    if (count > 1) {
-      constants.delete(varName);
-      tainted.add(varName);
-    }
-  }
-  let taintChanged = true;
-  while (taintChanged) {
-    taintChanged = false;
-    for (const [varName, deps] of dependencies) {
-      if (tainted.has(varName))
-        continue;
-      for (const dep of deps) {
-        if (tainted.has(dep)) {
-          tainted.add(varName);
-          constants.delete(varName);
-          taintChanged = true;
-          break;
-        }
-      }
-    }
-  }
-  const liveVariables = new Set;
-  const lastStmt = node.statements[node.statements.length - 1];
-  if (lastStmt) {
-    if (isAssignment(lastStmt)) {
-      const deps = new Set;
-      collectDependencies(lastStmt.value, deps);
-      for (const dep of deps) {
-        liveVariables.add(dep);
-      }
-    } else {
-      const deps = new Set;
-      collectDependencies(lastStmt, deps);
-      for (const dep of deps) {
-        liveVariables.add(dep);
-      }
-    }
-  }
-  let liveChanged = true;
-  while (liveChanged) {
-    liveChanged = false;
-    for (const [varName, deps] of dependencies) {
-      if (liveVariables.has(varName)) {
-        for (const dep of deps) {
-          if (!liveVariables.has(dep)) {
-            liveVariables.add(dep);
-            liveChanged = true;
-          }
-        }
-      }
-    }
-  }
-  const evaluationOrder = topologicalSort(dependencies, liveVariables);
-  return {
-    constants,
-    tainted,
-    dependencies,
-    liveVariables,
-    assignmentIndices,
-    evaluationOrder
-  };
-}
-function collectDependencies(node, deps) {
-  if (isIdentifier(node)) {
-    deps.add(node.name);
-    return false;
-  }
   if (isNumberLiteral(node)) {
-    return false;
-  }
-  if (isAssignment(node) || isNullishAssignment(node)) {
-    return collectDependencies(node.value, deps);
-  }
-  if (isBinaryOp(node)) {
-    const leftHasCall = collectDependencies(node.left, deps);
-    const rightHasCall = collectDependencies(node.right, deps);
-    return leftHasCall || rightHasCall;
-  }
-  if (isUnaryOp(node)) {
-    return collectDependencies(node.argument, deps);
-  }
-  if (isFunctionCall(node)) {
-    for (const arg of node.arguments) {
-      collectDependencies(arg, deps);
-    }
-    return true;
-  }
-  if (isConditionalExpression(node)) {
-    const condHasCall = collectDependencies(node.condition, deps);
-    const consHasCall = collectDependencies(node.consequent, deps);
-    const altHasCall = collectDependencies(node.alternate, deps);
-    return condHasCall || consHasCall || altHasCall;
-  }
-  if (isProgram(node)) {
-    let hasCall = false;
-    for (const stmt of node.statements) {
-      hasCall = collectDependencies(stmt, deps) || hasCall;
-    }
-    return hasCall;
-  }
-  return false;
-}
-function topologicalSort(dependencies, liveVariables) {
-  const result = [];
-  const visited = new Set;
-  const visiting = new Set;
-  function visit(varName) {
-    if (visited.has(varName))
-      return;
-    if (visiting.has(varName)) {
-      return;
-    }
-    visiting.add(varName);
-    const deps = dependencies.get(varName);
-    if (deps) {
-      for (const dep of deps) {
-        if (liveVariables.has(dep)) {
-          visit(dep);
-        }
-      }
-    }
-    visiting.delete(varName);
-    visited.add(varName);
-    result.push(varName);
-  }
-  for (const varName of liveVariables) {
-    visit(varName);
-  }
-  return result;
-}
-function propagateConstantsOptimal(node, analysis) {
-  if (!isProgram(node)) {
-    return { propagated: node, allConstants: new Map };
-  }
-  const allConstants = new Map(analysis.constants);
-  for (const varName of analysis.evaluationOrder) {
-    if (allConstants.has(varName))
-      continue;
-    if (analysis.tainted.has(varName))
-      continue;
-    const deps = analysis.dependencies.get(varName);
-    if (!deps)
-      continue;
-    let allDepsConstant = true;
-    for (const dep of deps) {
-      if (!allConstants.has(dep)) {
-        allDepsConstant = false;
-        break;
-      }
-    }
-    if (allDepsConstant) {
-      const assignmentIdx = analysis.assignmentIndices.get(varName);
-      if (assignmentIdx !== undefined) {
-        const stmt = node.statements[assignmentIdx];
-        if (stmt && isAssignment(stmt)) {
-          const evaluated = evaluateWithConstants(stmt.value, allConstants);
-          if (isNumberLiteral(evaluated)) {
-            allConstants.set(varName, evaluated.value);
-          }
-        }
-      }
-    }
-  }
-  const statements = node.statements.map((stmt) => replaceWithConstants(stmt, allConstants));
-  return {
-    propagated: {
-      type: "Program",
-      statements
-    },
-    allConstants
-  };
-}
-function evaluateWithConstants(node, constants) {
-  if (isIdentifier(node)) {
-    const value = constants.get(node.name);
-    if (value !== undefined) {
-      return number(value);
-    }
     return node;
   }
-  if (isNumberLiteral(node)) {
+  if (node.type === "Identifier") {
     return node;
   }
   if (isBinaryOp(node)) {
-    const left = evaluateWithConstants(node.left, constants);
-    const right = evaluateWithConstants(node.right, constants);
+    const left = optimize(node.left);
+    const right = optimize(node.right);
     if (isNumberLiteral(left) && isNumberLiteral(right)) {
       const result = evaluateBinaryOperation(node.operator, left.value, right.value);
       return number(result);
     }
-    return {
-      ...node,
-      left,
-      right
-    };
+    return binaryOp(left, node.operator, right);
   }
   if (isUnaryOp(node)) {
-    const argument = evaluateWithConstants(node.argument, constants);
+    const argument = optimize(node.argument);
     if (isNumberLiteral(argument)) {
       return number(-argument.value);
     }
-    return {
-      ...node,
-      argument
-    };
+    return unaryOp(argument);
   }
   if (isFunctionCall(node)) {
-    return {
-      ...node,
-      arguments: node.arguments.map((arg) => evaluateWithConstants(arg, constants))
-    };
-  }
-  if (isConditionalExpression(node)) {
-    const condition = evaluateWithConstants(node.condition, constants);
-    const consequent = evaluateWithConstants(node.consequent, constants);
-    const alternate = evaluateWithConstants(node.alternate, constants);
-    if (isNumberLiteral(condition)) {
-      return condition.value !== 0 ? consequent : alternate;
-    }
-    return {
-      ...node,
-      condition,
-      consequent,
-      alternate
-    };
-  }
-  if (isAssignment(node)) {
-    return {
-      ...node,
-      value: evaluateWithConstants(node.value, constants)
-    };
-  }
-  if (isNullishAssignment(node)) {
-    return {
-      ...node,
-      value: evaluateWithConstants(node.value, constants)
-    };
-  }
-  return node;
-}
-function replaceWithConstants(node, constants) {
-  return evaluateWithConstants(node, constants);
-}
-function eliminateDeadCodeOptimal(node, analysis, allConstants) {
-  if (!isProgram(node))
-    return node;
-  const lastStmt = node.statements[node.statements.length - 1];
-  if (lastStmt) {
-    const evaluated = evaluateWithConstants(lastStmt, allConstants);
-    if (isNumberLiteral(evaluated)) {
-      return evaluated;
-    }
-  }
-  const filteredStatements = [];
-  const variablesInUse = new Set;
-  for (const stmt of node.statements) {
-    collectDependencies(stmt, variablesInUse);
-  }
-  for (let i = 0;i < node.statements.length; i++) {
-    const stmt = node.statements[i];
-    if (!stmt)
-      continue;
-    if (i === node.statements.length - 1) {
-      filteredStatements.push(stmt);
-      continue;
-    }
-    if (isAssignment(stmt) || isNullishAssignment(stmt)) {
-      if (variablesInUse.has(stmt.name)) {
-        filteredStatements.push(stmt);
-      }
-    } else {
-      filteredStatements.push(stmt);
-    }
-  }
-  if (filteredStatements.length === 1) {
-    const singleStmt = filteredStatements[0];
-    if (!singleStmt) {
-      return node;
-    }
-    if (isNumberLiteral(singleStmt)) {
-      return singleStmt;
-    }
-    if (isAssignment(singleStmt) && isNumberLiteral(singleStmt.value)) {
-      if (!analysis.liveVariables.has(singleStmt.name)) {
-        return singleStmt.value;
-      }
-    }
-    const evaluated = evaluateWithConstants(singleStmt, allConstants);
-    if (isNumberLiteral(evaluated)) {
-      return evaluated;
-    }
+    const optimizedArgs = node.arguments.map((arg) => optimize(arg));
+    return functionCall(node.name, optimizedArgs);
   }
-  if (filteredStatements.length === 0) {
-    const lastStmt2 = node.statements[node.statements.length - 1];
-    if (lastStmt2 && isAssignment(lastStmt2) && isNumberLiteral(lastStmt2.value)) {
-      return lastStmt2.value;
-    }
-    return node;
-  }
-  return {
-    type: "Program",
-    statements: filteredStatements
-  };
-}
-function basicOptimize(node) {
   if (isAssignment(node)) {
-    return {
-      ...node,
-      value: basicOptimize(node.value)
-    };
-  }
-  if (isNullishAssignment(node)) {
-    return {
-      ...node,
-      value: basicOptimize(node.value)
-    };
-  }
-  if (isBinaryOp(node)) {
-    const left = basicOptimize(node.left);
-    const right = basicOptimize(node.right);
-    if (isNumberLiteral(left) && isNumberLiteral(right)) {
-      const result = evaluateBinaryOperation(node.operator, left.value, right.value);
-      return number(result);
-    }
-    return {
-      ...node,
-      left,
-      right
-    };
-  }
-  if (isUnaryOp(node)) {
-    const argument = basicOptimize(node.argument);
-    if (isNumberLiteral(argument)) {
-      return number(-argument.value);
-    }
-    return {
-      ...node,
-      argument
-    };
-  }
-  if (isFunctionCall(node)) {
-    return {
-      ...node,
-      arguments: node.arguments.map((arg) => basicOptimize(arg))
-    };
+    return assign(node.name, optimize(node.value));
   }
   if (isConditionalExpression(node)) {
-    const condition = basicOptimize(node.condition);
-    const consequent = basicOptimize(node.consequent);
-    const alternate = basicOptimize(node.alternate);
+    const condition = optimize(node.condition);
     if (isNumberLiteral(condition)) {
-      return condition.value !== 0 ? consequent : alternate;
+      return condition.value !== 0 ? optimize(node.consequent) : optimize(node.alternate);
     }
-    return {
-      ...node,
-      condition,
-      consequent,
-      alternate
-    };
+    const consequent = optimize(node.consequent);
+    const alternate = optimize(node.alternate);
+    return conditional(condition, consequent, alternate);
   }
   if (isProgram(node)) {
-    return {
-      ...node,
-      statements: node.statements.map((stmt) => basicOptimize(stmt))
-    };
+    const optimizedStatements = node.statements.map((stmt) => optimize(stmt));
+    return program(optimizedStatements);
   }
   return node;
 }
@@ -1332,7 +902,6 @@ export {
   isUnaryOp,
   isProgram,
   isNumberLiteral,
-  isNullishAssignment,
   isIdentifier,
   isFunctionCall,
   isConditionalExpression,