littlewing 0.4.1 → 0.5.0

package/dist/index.js

@@ -16,13 +16,23 @@ __export(exports_ast, {
   unaryOp: () => unaryOp,
   subtract: () => subtract,
   number: () => number,
+  nullishAssign: () => nullishAssign,
+  notEquals: () => notEquals,
   negate: () => negate,
   multiply: () => multiply,
   modulo: () => modulo,
+  logicalOr: () => logicalOr,
+  logicalAnd: () => logicalAnd,
+  lessThan: () => lessThan,
+  lessEqual: () => lessEqual,
   identifier: () => identifier,
+  greaterThan: () => greaterThan,
+  greaterEqual: () => greaterEqual,
   functionCall: () => functionCall,
   exponentiate: () => exponentiate,
+  equals: () => equals,
   divide: () => divide,
+  conditional: () => conditional,
   binaryOp: () => binaryOp,
   assign: () => assign,
   add: () => add
@@ -68,6 +78,21 @@ function assign(name, value) {
     value
   };
 }
+function nullishAssign(name, value) {
+  return {
+    type: "NullishAssignment",
+    name,
+    value
+  };
+}
+function conditional(condition, consequent, alternate) {
+  return {
+    type: "ConditionalExpression",
+    condition,
+    consequent,
+    alternate
+  };
+}
 function add(left, right) {
   return binaryOp(left, "+", right);
 }
@@ -89,6 +114,30 @@ function exponentiate(left, right) {
 function negate(argument) {
   return unaryOp(argument);
 }
+function equals(left, right) {
+  return binaryOp(left, "==", right);
+}
+function notEquals(left, right) {
+  return binaryOp(left, "!=", right);
+}
+function lessThan(left, right) {
+  return binaryOp(left, "<", right);
+}
+function greaterThan(left, right) {
+  return binaryOp(left, ">", right);
+}
+function lessEqual(left, right) {
+  return binaryOp(left, "<=", right);
+}
+function greaterEqual(left, right) {
+  return binaryOp(left, ">=", right);
+}
+function logicalAnd(left, right) {
+  return binaryOp(left, "&&", right);
+}
+function logicalOr(left, right) {
+  return binaryOp(left, "||", right);
+}
 // src/types.ts
 var TokenType;
 ((TokenType2) => {
@@ -100,10 +149,21 @@ var TokenType;
   TokenType2["SLASH"] = "SLASH";
   TokenType2["PERCENT"] = "PERCENT";
   TokenType2["CARET"] = "CARET";
+  TokenType2["DOUBLE_EQUALS"] = "DOUBLE_EQUALS";
+  TokenType2["NOT_EQUALS"] = "NOT_EQUALS";
+  TokenType2["LESS_THAN"] = "LESS_THAN";
+  TokenType2["GREATER_THAN"] = "GREATER_THAN";
+  TokenType2["LESS_EQUAL"] = "LESS_EQUAL";
+  TokenType2["GREATER_EQUAL"] = "GREATER_EQUAL";
+  TokenType2["LOGICAL_AND"] = "LOGICAL_AND";
+  TokenType2["LOGICAL_OR"] = "LOGICAL_OR";
   TokenType2["LPAREN"] = "LPAREN";
   TokenType2["RPAREN"] = "RPAREN";
   TokenType2["EQUALS"] = "EQUALS";
   TokenType2["COMMA"] = "COMMA";
+  TokenType2["QUESTION"] = "QUESTION";
+  TokenType2["COLON"] = "COLON";
+  TokenType2["NULLISH_ASSIGN"] = "NULLISH_ASSIGN";
   TokenType2["EOF"] = "EOF";
 })(TokenType ||= {});
 function isNumberLiteral(node) {
@@ -127,6 +187,12 @@ function isAssignment(node) {
 function isProgram(node) {
   return node.type === "Program";
 }
+function isConditionalExpression(node) {
+  return node.type === "ConditionalExpression";
+}
+function isNullishAssignment(node) {
+  return node.type === "NullishAssignment";
+}
 
 // src/codegen.ts
 class CodeGenerator {
@@ -145,6 +211,10 @@ 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`);
   }
   generateProgram(node) {
@@ -179,6 +249,18 @@ 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);
+    const alternate = this.generate(node.alternate);
+    const conditionNeedsParens = isAssignment(node.condition) || isBinaryOp(node.condition) && this.getPrecedence(node.condition.operator) <= 2;
+    const conditionCode = conditionNeedsParens ? `(${condition})` : condition;
+    return `${conditionCode} ? ${consequent} : ${alternate}`;
+  }
   needsParensLeft(node, operator) {
     if (!isBinaryOp(node))
       return false;
@@ -202,14 +284,25 @@ class CodeGenerator {
   getPrecedence(operator) {
     switch (operator) {
       case "^":
-        return 4;
+        return 8;
       case "*":
       case "/":
       case "%":
-        return 3;
+        return 7;
       case "+":
       case "-":
-        return 2;
+        return 6;
+      case "==":
+      case "!=":
+      case "<":
+      case ">":
+      case "<=":
+      case ">=":
+        return 5;
+      case "&&":
+        return 4;
+      case "||":
+        return 3;
       default:
         return 0;
     }
@@ -309,14 +402,64 @@ class Lexer {
         this.position++;
         return { type: "RPAREN" /* RPAREN */, value: ")", position: start };
       case "=":
+        if (this.peek() === "=") {
+          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() === "=") {
+          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() === "=") {
+          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() === "=") {
+          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 ":":
+        this.position++;
+        return { type: "COLON" /* COLON */, value: ":", position: start };
       case ",":
         this.position++;
         return { type: "COMMA" /* COMMA */, value: ",", position: start };
       case ";":
         this.position++;
         return this.nextToken();
+      case "&":
+        if (this.peek() === "&") {
+          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() === "|") {
+          this.position += 2;
+          return { type: "LOGICAL_OR" /* LOGICAL_OR */, value: "||", position: start };
+        }
+        throw new Error(`Unexpected character '${char}' at position ${start}`);
       default:
         throw new Error(`Unexpected character '${char}' at position ${start}`);
     }
@@ -389,6 +532,9 @@ class Lexer {
   peek() {
     return this.getCharAt(this.position + 1);
   }
+  peekAhead(n) {
+    return this.getCharAt(this.position + n);
+  }
   isDigit(char) {
     return char >= "0" && char <= "9";
   }
@@ -442,12 +588,38 @@ class Parser {
         }
         const identName = left.name;
         this.advance();
-        const value = this.parseExpression(precedence + 1);
+        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
+        };
+      } else if (token.type === "QUESTION" /* QUESTION */) {
+        this.advance();
+        const consequent = this.parseExpression(0);
+        if (this.peek().type !== "COLON" /* COLON */) {
+          throw new Error("Expected : in ternary expression");
+        }
+        this.advance();
+        const alternate = this.parseExpression(precedence);
+        left = {
+          type: "ConditionalExpression",
+          condition: left,
+          consequent,
+          alternate
+        };
       } else if (this.isBinaryOperator(token.type)) {
         const operator = token.value;
         this.advance();
@@ -529,25 +701,39 @@ class Parser {
   getPrecedence(type) {
     switch (type) {
       case "EQUALS" /* EQUALS */:
+      case "NULLISH_ASSIGN" /* NULLISH_ASSIGN */:
         return 1;
+      case "QUESTION" /* QUESTION */:
+        return 2;
+      case "LOGICAL_OR" /* LOGICAL_OR */:
+        return 3;
+      case "LOGICAL_AND" /* LOGICAL_AND */:
+        return 4;
+      case "DOUBLE_EQUALS" /* DOUBLE_EQUALS */:
+      case "NOT_EQUALS" /* NOT_EQUALS */:
+      case "LESS_THAN" /* LESS_THAN */:
+      case "GREATER_THAN" /* GREATER_THAN */:
+      case "LESS_EQUAL" /* LESS_EQUAL */:
+      case "GREATER_EQUAL" /* GREATER_EQUAL */:
+        return 5;
       case "PLUS" /* PLUS */:
       case "MINUS" /* MINUS */:
-        return 2;
+        return 6;
       case "STAR" /* STAR */:
       case "SLASH" /* SLASH */:
       case "PERCENT" /* PERCENT */:
-        return 3;
+        return 7;
       case "CARET" /* CARET */:
-        return 4;
+        return 8;
       default:
         return 0;
     }
   }
   getUnaryPrecedence() {
-    return 5;
+    return 6;
   }
   isBinaryOperator(type) {
-    return type === "PLUS" /* PLUS */ || type === "MINUS" /* MINUS */ || type === "STAR" /* STAR */ || type === "SLASH" /* SLASH */ || type === "PERCENT" /* PERCENT */ || type === "CARET" /* CARET */;
+    return type === "PLUS" /* PLUS */ || type === "MINUS" /* MINUS */ || type === "STAR" /* STAR */ || type === "SLASH" /* SLASH */ || type === "PERCENT" /* PERCENT */ || type === "CARET" /* CARET */ || type === "DOUBLE_EQUALS" /* DOUBLE_EQUALS */ || type === "NOT_EQUALS" /* NOT_EQUALS */ || type === "LESS_THAN" /* LESS_THAN */ || type === "GREATER_THAN" /* GREATER_THAN */ || type === "LESS_EQUAL" /* LESS_EQUAL */ || type === "GREATER_EQUAL" /* GREATER_EQUAL */ || type === "LOGICAL_AND" /* LOGICAL_AND */ || type === "LOGICAL_OR" /* LOGICAL_OR */;
   }
   peek() {
     if (this.current >= this.tokens.length) {
@@ -593,6 +779,10 @@ 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`);
   }
   executeProgram(node) {
@@ -634,6 +824,22 @@ class Executor {
         return left % right;
       case "^":
         return left ** right;
+      case "==":
+        return left === right ? 1 : 0;
+      case "!=":
+        return left !== right ? 1 : 0;
+      case "<":
+        return left < right ? 1 : 0;
+      case ">":
+        return left > right ? 1 : 0;
+      case "<=":
+        return left <= right ? 1 : 0;
+      case ">=":
+        return left >= right ? 1 : 0;
+      case "&&":
+        return left !== 0 && right !== 0 ? 1 : 0;
+      case "||":
+        return left !== 0 || right !== 0 ? 1 : 0;
       default:
         throw new Error(`Unknown operator: ${node.operator}`);
     }
@@ -661,6 +867,18 @@ class Executor {
     this.variables.set(node.name, value);
     return value;
   }
+  executeNullishAssignment(node) {
+    if (this.variables.has(node.name)) {
+      return this.variables.get(node.name);
+    }
+    const value = this.execute(node.value);
+    this.variables.set(node.name, value);
+    return value;
+  }
+  executeConditionalExpression(node) {
+    const condition = this.execute(node.condition);
+    return condition !== 0 ? this.execute(node.consequent) : this.execute(node.alternate);
+  }
 }
 function execute(source, context) {
   const ast = parseSource(source);
@@ -669,21 +887,371 @@ 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 (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)) {
+    return node;
+  }
+  if (isBinaryOp(node)) {
+    const left = evaluateWithConstants(node.left, constants);
+    const right = evaluateWithConstants(node.right, constants);
+    if (isNumberLiteral(left) && isNumberLiteral(right)) {
+      const result = evaluateBinaryOp(node.operator, left.value, right.value);
+      return number(result);
+    }
+    return {
+      ...node,
+      left,
+      right
+    };
+  }
+  if (isUnaryOp(node)) {
+    const argument = evaluateWithConstants(node.argument, constants);
+    if (isNumberLiteral(argument)) {
+      return number(-argument.value);
+    }
+    return {
+      ...node,
+      argument
+    };
+  }
+  if (isFunctionCall(node)) {
     return {
       ...node,
-      statements: node.statements.map((stmt) => optimize(stmt))
+      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;
+    }
+  }
+  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: optimize(node.value)
+      value: basicOptimize(node.value)
+    };
+  }
+  if (isNullishAssignment(node)) {
+    return {
+      ...node,
+      value: basicOptimize(node.value)
     };
   }
   if (isBinaryOp(node)) {
-    const left = optimize(node.left);
-    const right = optimize(node.right);
+    const left = basicOptimize(node.left);
+    const right = basicOptimize(node.right);
     if (isNumberLiteral(left) && isNumberLiteral(right)) {
       const result = evaluateBinaryOp(node.operator, left.value, right.value);
       return number(result);
@@ -695,7 +1263,7 @@ function optimize(node) {
     };
   }
   if (isUnaryOp(node)) {
-    const argument = optimize(node.argument);
+    const argument = basicOptimize(node.argument);
     if (isNumberLiteral(argument)) {
       return number(-argument.value);
     }
@@ -707,7 +1275,27 @@ function optimize(node) {
   if (isFunctionCall(node)) {
     return {
       ...node,
-      arguments: node.arguments.map((arg) => optimize(arg))
+      arguments: node.arguments.map((arg) => basicOptimize(arg))
+    };
+  }
+  if (isConditionalExpression(node)) {
+    const condition = basicOptimize(node.condition);
+    const consequent = basicOptimize(node.consequent);
+    const alternate = basicOptimize(node.alternate);
+    if (isNumberLiteral(condition)) {
+      return condition.value !== 0 ? consequent : alternate;
+    }
+    return {
+      ...node,
+      condition,
+      consequent,
+      alternate
+    };
+  }
+  if (isProgram(node)) {
+    return {
+      ...node,
+      statements: node.statements.map((stmt) => basicOptimize(stmt))
     };
   }
   return node;
@@ -732,6 +1320,22 @@ function evaluateBinaryOp(operator, left, right) {
       return left % right;
     case "^":
       return left ** right;
+    case "==":
+      return left === right ? 1 : 0;
+    case "!=":
+      return left !== right ? 1 : 0;
+    case "<":
+      return left < right ? 1 : 0;
+    case ">":
+      return left > right ? 1 : 0;
+    case "<=":
+      return left <= right ? 1 : 0;
+    case ">=":
+      return left >= right ? 1 : 0;
+    case "&&":
+      return left !== 0 && right !== 0 ? 1 : 0;
+    case "||":
+      return left !== 0 || right !== 0 ? 1 : 0;
     default:
       throw new Error(`Unknown operator: ${operator}`);
   }
@@ -742,8 +1346,10 @@ export {
   isUnaryOp,
   isProgram,
   isNumberLiteral,
+  isNullishAssignment,
   isIdentifier,
   isFunctionCall,
+  isConditionalExpression,
   isBinaryOp,
   isAssignment,
   generate,