littlewing 1.1.0 → 1.2.0

package/README.md

@@ -25,11 +25,12 @@ evaluate("score = 85; grade = score >= 90 ? 100 : 90", {
 - **Numbers-only** - Every value is a number. Simple, predictable, fast.
 - **Zero dependencies** - 7.8 KB gzipped, perfect for browser bundles
 - **O(n) performance** - Linear time parsing and execution
-- **Safe evaluation** - No eval(), no code generation, no security risks
+- **JIT compiler** - Optional compilation for 3-4x faster repeated execution
+- **Safe evaluation** - Tree-walk interpreter requires no code generation
 - **Timestamp arithmetic** - Built-in date/time functions using numeric timestamps
 - **Extensible** - Add custom functions and variables via context
 - **Type-safe** - Full TypeScript support with strict types
-- **Excellent test coverage** - 502 tests with 99.45% function coverage, 98.57% line coverage
+- **Excellent test coverage** - 607 tests with 99.45% function coverage, 98.57% line coverage
 
 ## Installation
 
@@ -174,6 +175,46 @@ evaluate(ast); // → 4
 evaluate(ast); // → 4 (no re-parsing)
 ```
 
+#### `compile(input: string | ASTNode): CompiledExpression`
+
+Compile source code or AST to a JavaScript function for faster repeated execution. Best for hot paths where the same expression is evaluated many times.
+
+```typescript
+import { compile } from "littlewing";
+
+// Compile once
+const expr = compile("x * 2 + y");
+
+// Execute many times with different contexts (5-10x faster than evaluate)
+expr.execute({ variables: { x: 10, y: 5 } }); // → 25
+expr.execute({ variables: { x: 20, y: 3 } }); // → 43
+expr.execute({ variables: { x: 30, y: 1 } }); // → 61
+
+// Inspect generated JavaScript code
+console.log(expr.source); // Shows generated code for debugging
+```
+
+**Performance (repeated execution after compilation):**
+
+- Small scripts: **22.8x faster** (330.62 ns → 14.50 ns per execution)
+- Medium scripts: **12.3x faster** (1.94 µs → 157.66 ns per execution)
+- Large scripts: **99.9x faster** (9.13 µs → 91.39 ns per execution)
+
+**Important:** Compilation has overhead. For one-time execution, use `evaluate()` instead:
+
+- Small: `evaluate()` is 3.7x faster (1.43 µs vs 5.26 µs including compilation)
+- Medium: `evaluate()` is 2.5x faster (7.13 µs vs 17.76 µs including compilation)
+- Large: `evaluate()` is 1.7x faster (42.80 µs vs 71.73 µs including compilation)
+
+**CompiledExpression interface:**
+
+```typescript
+interface CompiledExpression {
+	execute(context?: ExecutionContext): number;
+	source: string; // Generated JavaScript code
+}
+```
+
 #### `parse(source: string): ASTNode`
 
 Parse source into an Abstract Syntax Tree without evaluating. Useful for parse-once, execute-many scenarios.
@@ -415,7 +456,9 @@ The `defaultContext` includes these built-in functions:
 
 ## Performance Optimization
 
-For expressions that are executed multiple times with different contexts, parse once and reuse the AST:
+### Parse Once, Evaluate Many
+
+For expressions executed multiple times, parse once and reuse the AST:
 
 ```typescript
 import { evaluate, parse } from "littlewing";
@@ -437,6 +480,57 @@ evaluate(formula, {
 // This avoids lexing and parsing overhead on every execution
 ```
 
+### JIT Compilation for Maximum Performance
+
+For hot paths where the same expression is evaluated hundreds or thousands of times, use the JIT compiler:
+
+```typescript
+import { compile } from "littlewing";
+
+// Compile once (generates optimized JavaScript function)
+const formula = compile("price * quantity * (1 - discount) * (1 + taxRate)");
+
+// Execute many times with different contexts (5-10x faster than tree-walk interpreter)
+formula.execute({
+	variables: { price: 10, quantity: 5, discount: 0.1, taxRate: 0.08 },
+});
+formula.execute({
+	variables: { price: 20, quantity: 3, discount: 0.15, taxRate: 0.08 },
+});
+formula.execute({
+	variables: { price: 15, quantity: 10, discount: 0.2, taxRate: 0.08 },
+});
+```
+
+**When to use JIT:**
+
+- ✅ Same expression evaluated 10+ times with different variables
+- ✅ Large scripts (>50 lines)
+- ✅ Performance-critical loops
+- ✅ Long-running applications that amortize compilation cost
+
+**When to use tree-walk interpreter:**
+
+- ✅ One-time or infrequent evaluation
+- ✅ Small scripts (<10 lines)
+- ✅ Compilation time matters more than execution speed
+
+**Performance comparison:**
+
+Execution time only (after compilation):
+
+- Small scripts: JIT is **22.8x faster** (330.62 ns → 14.50 ns per execution)
+- Medium scripts: JIT is **12.3x faster** (1.94 µs → 157.66 ns per execution)
+- Large scripts: JIT is **99.9x faster** (9.13 µs → 91.39 ns per execution)
+
+Full pipeline (including compilation overhead):
+
+- Small scripts: `evaluate()` is **3.7x faster** (1.43 µs vs 5.26 µs)
+- Medium scripts: `evaluate()` is **2.5x faster** (7.13 µs vs 17.76 µs)
+- Large scripts: `evaluate()` is **1.7x faster** (42.80 µs vs 71.73 µs)
+
+See [JIT_IMPLEMENTATION.md](./JIT_IMPLEMENTATION.md) for detailed performance analysis and usage patterns.
+
 ## Use Cases
 
 - **User-defined formulas** - Let users write safe arithmetic expressions

package/dist/index.d.ts

@@ -294,6 +294,67 @@ interface ExecutionContext {
 */
 declare function evaluate(input: string | ASTNode, context?: ExecutionContext): RuntimeValue;
 /**
+* Compiled expression that can be executed multiple times
+* Provides faster repeated execution compared to tree-walk interpreter
+*/
+interface CompiledExpression {
+	/**
+	* Execute the compiled expression with optional context
+	* @param context - Execution context with variables and functions
+	* @returns The evaluated result
+	*/
+	execute: (context?: ExecutionContext) => RuntimeValue;
+	/**
+	* Generated JavaScript source code (for debugging and inspection)
+	*/
+	source: string;
+}
+/**
+* Compile source code or AST to a JavaScript function for faster repeated execution
+*
+* JIT compilation trades compilation time for execution speed:
+* - First call: Parse + Optimize + Compile (~10-50µs depending on size)
+* - Subsequent calls: Direct JavaScript execution (~1-5µs, 5-10x faster)
+*
+* The compiler automatically optimizes the AST before code generation:
+* - Constant folding: `2 + 3` → `5` (safe constants only)
+* - Dead code elimination: removes unused variable assignments
+* - Expression simplification: `1 ? x : y` → `x`
+*
+* Optimization is safe because:
+* - Constant folding errors (e.g., division by zero) propagate to compile-time
+* - Variables that could be external are preserved (no unsafe DCE)
+* - The optimizer respects ExecutionContext override semantics
+*
+* The compiler generates optimized JavaScript code:
+* - Uses comma operator instead of IIFEs for better performance
+* - Only initializes variables that are actually used
+* - Pre-declares temporary variables for reuse
+*
+* Best for expressions that are evaluated many times with different contexts.
+*
+* Security: Uses `new Function()` to generate executable code. Safe for trusted
+* input only. For untrusted input, use the tree-walk interpreter instead.
+*
+* @param input - Either a source code string or an AST node
+* @returns Compiled expression that can be executed multiple times
+* @throws {Error} If compilation fails or AST contains invalid operations (e.g., constant division by zero)
+*
+* @example
+* ```typescript
+* const expr = compile('x * 2 + y')
+* expr.execute({ variables: { x: 10, y: 5 } }) // 25
+* expr.execute({ variables: { x: 20, y: 3 } }) // 43
+* ```
+*
+* @example Automatic optimization
+* ```typescript
+* const expr = compile('2 + 3 * 4')  // Automatically optimized to 14
+* expr.execute() // Fast execution of pre-folded constant
+* ```
+*/
+declare function compile(input: string | ASTNode): CompiledExpression;
+/**
 * Optimize an AST using constant folding, expression simplification, and dead code elimination.
 *
 * This optimizer performs SAFE optimizations that preserve program semantics:
@@ -763,4 +824,4 @@ declare function visit<T>(node: ASTNode, visitor: Visitor<T>): T;
 * )
 */
 declare function visitPartial<T>(node: ASTNode, visitor: Partial<Visitor<T>>, defaultHandler: (node: ASTNode, recurse: (n: ASTNode) => T) => T): T;
-export { visitPartial, visit, parse, optimize, exports_math as math, isUnaryOp, isProgram, isNumberLiteral, isIdentifier, isFunctionCall, isConditionalExpression, isBinaryOp, isAssignment, humanize, generate, extractInputVariables, evaluate, defaultContext, exports_datetime as datetime, exports_ast as ast, Visitor, UnaryOp, RuntimeValue, Program, Operator, NumberLiteral, NodeKind, Identifier, HumanizeOptions, FunctionCall, ExecutionContext, ConditionalExpression, BinaryOp, Assignment, ASTNode };
+export { visitPartial, visit, parse, optimize, exports_math as math, isUnaryOp, isProgram, isNumberLiteral, isIdentifier, isFunctionCall, isConditionalExpression, isBinaryOp, isAssignment, humanize, generate, extractInputVariables, evaluate, defaultContext, exports_datetime as datetime, compile, exports_ast as ast, Visitor, UnaryOp, RuntimeValue, Program, Operator, NumberLiteral, NodeKind, Identifier, HumanizeOptions, FunctionCall, ExecutionContext, ConditionalExpression, CompiledExpression, BinaryOp, Assignment, ASTNode };

package/dist/index.js

@@ -194,18 +194,23 @@ function advance(cursor) {
   return char;
 }
 function skipWhitespace(cursor) {
-  let c = peek(cursor);
-  while (c === 32 || c === 10 || c === 13 || c === 9) {
-    advance(cursor);
-    c = peek(cursor);
+  while (cursor.pos < cursor.len) {
+    const c = cursor.source.charCodeAt(cursor.pos);
+    if (c === 32 || c === 10 || c === 13 || c === 9) {
+      cursor.pos++;
+    } else {
+      break;
+    }
   }
 }
 function skipComment(cursor) {
-  if (peek(cursor) === 47 && peek(cursor, 1) === 47) {
-    let ch = peek(cursor);
-    while (ch !== 10 && ch !== 13 && ch !== 0) {
-      advance(cursor);
-      ch = peek(cursor);
+  if (cursor.pos < cursor.len - 1 && cursor.source.charCodeAt(cursor.pos) === 47 && cursor.source.charCodeAt(cursor.pos + 1) === 47) {
+    cursor.pos += 2;
+    while (cursor.pos < cursor.len) {
+      const ch = cursor.source.charCodeAt(cursor.pos);
+      if (ch === 10 || ch === 13)
+        break;
+      cursor.pos++;
     }
   }
 }
@@ -326,53 +331,68 @@ function nextToken(cursor) {
 }
 function lexNumber(cursor) {
   const start = cursor.pos;
-  let hasDecimal = false;
-  let hasExponent = false;
-  let ch = peek(cursor);
-  if (ch === 46) {
-    hasDecimal = true;
-    advance(cursor);
-    ch = peek(cursor);
+  const { source, len } = cursor;
+  let pos = cursor.pos;
+  if (source.charCodeAt(pos) === 46) {
+    pos++;
+    while (pos < len && source.charCodeAt(pos) >= 48 && source.charCodeAt(pos) <= 57) {
+      pos++;
+    }
+    const ch = pos < len ? source.charCodeAt(pos) : 0;
+    if (ch === 101 || ch === 69) {
+      pos = lexExponent(source, len, pos);
+    }
+    cursor.pos = pos;
+    return [0 /* Number */, start, pos];
   }
-  while (ch !== 0) {
-    if (isDigit(ch)) {
-      advance(cursor);
-      ch = peek(cursor);
-    } else if (ch === 46 && !hasDecimal && !hasExponent) {
-      hasDecimal = true;
-      advance(cursor);
-      ch = peek(cursor);
-    } else if ((ch === 101 || ch === 69) && !hasExponent) {
-      hasExponent = true;
-      advance(cursor);
-      ch = peek(cursor);
-      if (ch === 43 || ch === 45) {
-        advance(cursor);
-        ch = peek(cursor);
-      }
-      if (!isDigit(ch)) {
-        throw new Error(`Invalid number: expected digit after exponent at position ${cursor.pos}`);
-      }
-      while (isDigit(ch)) {
-        advance(cursor);
-        ch = peek(cursor);
-      }
-      break;
-    } else {
-      break;
+  while (pos < len && source.charCodeAt(pos) >= 48 && source.charCodeAt(pos) <= 57) {
+    pos++;
+  }
+  if (pos < len && source.charCodeAt(pos) === 46) {
+    pos++;
+    while (pos < len && source.charCodeAt(pos) >= 48 && source.charCodeAt(pos) <= 57) {
+      pos++;
     }
   }
-  return [0 /* Number */, start, cursor.pos];
+  if (pos < len) {
+    const ch = source.charCodeAt(pos);
+    if (ch === 101 || ch === 69) {
+      pos = lexExponent(source, len, pos);
+    }
+  }
+  cursor.pos = pos;
+  return [0 /* Number */, start, pos];
+}
+function lexExponent(source, len, pos) {
+  pos++;
+  if (pos < len) {
+    const next = source.charCodeAt(pos);
+    if (next === 43 || next === 45) {
+      pos++;
+    }
+  }
+  if (pos >= len || !isDigit(source.charCodeAt(pos))) {
+    throw new Error(`Invalid number: expected digit after exponent at position ${pos}`);
+  }
+  while (pos < len && isDigit(source.charCodeAt(pos))) {
+    pos++;
+  }
+  return pos;
 }
 function lexIdentifier(cursor) {
   const start = cursor.pos;
-  advance(cursor);
-  let ch = peek(cursor);
-  while (isAlpha(ch) || isDigit(ch) || ch === 95) {
-    advance(cursor);
-    ch = peek(cursor);
+  const { source, len } = cursor;
+  let pos = cursor.pos + 1;
+  while (pos < len) {
+    const ch = source.charCodeAt(pos);
+    if (ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch >= 48 && ch <= 57 || ch === 95) {
+      pos++;
+    } else {
+      break;
+    }
   }
-  return [1 /* Identifier */, start, cursor.pos];
+  cursor.pos = pos;
+  return [1 /* Identifier */, start, pos];
 }
 
 // src/visitor.ts
@@ -383,7 +403,8 @@ function visit(node, visitor) {
 }
 function visitPartial(node, visitor, defaultHandler) {
   const recurse = (n) => visitPartial(n, visitor, defaultHandler);
-  switch (node[0]) {
+  const kind = node[0];
+  switch (kind) {
     case 0 /* Program */:
       return visitor.Program ? visitor.Program(node, recurse) : defaultHandler(node, recurse);
     case 1 /* NumberLiteral */:
@@ -557,25 +578,16 @@ function containsVariableReference(node) {
   return collectAllIdentifiers(node).size > 0;
 }
 // src/codegen.ts
-function needsParensLeft(node, operator) {
-  if (!isBinaryOp(node))
-    return false;
-  const nodePrecedence = getOperatorPrecedence(node[2]);
-  const operatorPrecedence = getOperatorPrecedence(operator);
-  if (operator === "^") {
-    return nodePrecedence <= operatorPrecedence;
-  }
-  return nodePrecedence < operatorPrecedence;
-}
-function needsParensRight(node, operator) {
+function needsParens(node, operator, isLeft) {
   if (!isBinaryOp(node))
     return false;
   const nodePrecedence = getOperatorPrecedence(node[2]);
   const operatorPrecedence = getOperatorPrecedence(operator);
-  if (operator === "^") {
-    return nodePrecedence < operatorPrecedence;
+  const isRightAssociative = operator === "^";
+  if (isRightAssociative) {
+    return isLeft ? nodePrecedence <= operatorPrecedence : nodePrecedence < operatorPrecedence;
   }
-  return nodePrecedence <= operatorPrecedence;
+  return isLeft ? nodePrecedence < operatorPrecedence : nodePrecedence <= operatorPrecedence;
 }
 function generate(node) {
   return visit(node, {
@@ -595,9 +607,9 @@ function generate(node) {
       const rightNode = n[3];
       const left = recurse(leftNode);
       const right = recurse(rightNode);
-      const leftNeedsParens = needsParensLeft(leftNode, operator) || operator === "^" && isUnaryOp(leftNode);
+      const leftNeedsParens = needsParens(leftNode, operator, true) || operator === "^" && isUnaryOp(leftNode);
       const leftCode = leftNeedsParens ? `(${left})` : left;
-      const rightNeedsParens = needsParensRight(rightNode, operator);
+      const rightNeedsParens = needsParens(rightNode, operator, false);
       const rightCode = rightNeedsParens ? `(${right})` : right;
       return `${leftCode} ${operator} ${rightCode}`;
     },
@@ -605,8 +617,8 @@ function generate(node) {
       const operator = n[1];
       const argumentNode = n[2];
       const arg = recurse(argumentNode);
-      const needsParens = isBinaryOp(argumentNode) || isAssignment(argumentNode);
-      const argCode = needsParens ? `(${arg})` : arg;
+      const needsParens2 = isBinaryOp(argumentNode) || isAssignment(argumentNode);
+      const argCode = needsParens2 ? `(${arg})` : arg;
       return `${operator}${argCode}`;
     },
     FunctionCall: (n, recurse) => {
@@ -781,14 +793,8 @@ function humanizeNode(node, operatorPhrases, functionPhrases, options) {
   });
 }
 function humanize(node, options = {}) {
-  const operatorPhrases = {
-    ...DEFAULT_OPERATOR_PHRASES,
-    ...options.operatorPhrases
-  };
-  const functionPhrases = {
-    ...DEFAULT_FUNCTION_PHRASES,
-    ...options.functionPhrases
-  };
+  const operatorPhrases = options.operatorPhrases ? { ...DEFAULT_OPERATOR_PHRASES, ...options.operatorPhrases } : DEFAULT_OPERATOR_PHRASES;
+  const functionPhrases = options.functionPhrases ? { ...DEFAULT_FUNCTION_PHRASES, ...options.functionPhrases } : DEFAULT_FUNCTION_PHRASES;
   return humanizeNode(node, operatorPhrases, functionPhrases, options);
 }
 // src/parser.ts
@@ -815,7 +821,7 @@ function parse(source) {
     currentToken: nextToken(cursor)
   };
   const statements = [];
-  while (peekKind(state) !== 23 /* Eof */) {
+  while (state.currentToken[0] !== 23 /* Eof */) {
     statements.push(parseExpression(state, 0));
   }
   if (statements.length === 0) {
@@ -833,7 +839,8 @@ function parse(source) {
 function parseExpression(state, minPrecedence) {
   let left = parsePrefix(state);
   while (true) {
-    const precedence = getTokenPrecedence(peekKind(state));
+    const kind = state.currentToken[0];
+    const precedence = getTokenPrecedence(kind);
     if (precedence === 0 || precedence < minPrecedence) {
       break;
     }
@@ -845,12 +852,12 @@ function parsePrefix(state) {
   const tokenKind = peekKind(state);
   if (tokenKind === 3 /* Minus */) {
     advance2(state);
-    const argument = parseExpression(state, getUnaryPrecedence());
+    const argument = parseExpression(state, UNARY_PRECEDENCE);
     return unaryOp("-", argument);
   }
   if (tokenKind === 8 /* Bang */) {
     advance2(state);
-    const argument = parseExpression(state, getUnaryPrecedence());
+    const argument = parseExpression(state, UNARY_PRECEDENCE);
     return unaryOp("!", argument);
   }
   if (tokenKind === 17 /* LParen */) {
@@ -909,7 +916,7 @@ function parseInfix(state, left, precedence) {
     return conditional(left, consequent, alternate);
   }
   if (isBinaryOperator(tokenKind)) {
-    const operator = getOperatorFromToken(state.currentToken, state.cursor);
+    const operator = readText(state.cursor, state.currentToken);
     advance2(state);
     const isRightAssociative = operator === "^";
     const right = parseExpression(state, isRightAssociative ? precedence : precedence + 1);
@@ -918,10 +925,10 @@ function parseInfix(state, left, precedence) {
   throw new Error("Unexpected token in infix position");
 }
 function parseFunctionArguments(state) {
-  const args = [];
   if (peekKind(state) === 18 /* RParen */) {
-    return args;
+    return [];
   }
+  const args = [];
   args.push(parseExpression(state, 0));
   while (peekKind(state) === 20 /* Comma */) {
     advance2(state);
@@ -929,15 +936,10 @@ function parseFunctionArguments(state) {
   }
   return args;
 }
-function getUnaryPrecedence() {
-  return 7;
-}
+var UNARY_PRECEDENCE = 7;
 function isBinaryOperator(kind) {
   return BINARY_OPERATOR_TOKENS.has(kind);
 }
-function getOperatorFromToken(token, cursor) {
-  return readText(cursor, token);
-}
 function peekKind(state) {
   return state.currentToken[0];
 }
@@ -1000,13 +1002,13 @@ function evaluateNode(node, context, variables, externalVariables) {
     Assignment: (n, recurse) => {
       const name = n[1];
       const valueNode = n[2];
+      const value = recurse(valueNode);
       if (externalVariables.has(name)) {
         const externalValue = variables.get(name);
         if (externalValue !== undefined) {
           return externalValue;
         }
       }
-      const value = recurse(valueNode);
       variables.set(name, value);
       return value;
     },
@@ -1020,23 +1022,24 @@ function evaluateNode(node, context, variables, externalVariables) {
 }
 function evaluate(input, context = {}) {
   const node = typeof input === "string" ? parse(input) : input;
-  const variables = new Map(Object.entries(context.variables || {}));
-  const externalVariables = new Set(Object.keys(context.variables || {}));
+  const entries = Object.entries(context.variables || {});
+  const variables = new Map(entries);
+  const externalVariables = new Set(entries.map(([key]) => key));
   return evaluateNode(node, context, variables, externalVariables);
 }
 // src/optimizer.ts
 function eliminateDeadCode(program2) {
   const statements = program2[1];
   const liveVars = new Set;
-  const keptStatements = [];
+  const keptIndices = [];
   for (let i = statements.length - 1;i >= 0; i--) {
     const stmt = statements[i];
     if (!stmt)
       continue;
     if (i === statements.length - 1) {
-      keptStatements.push(stmt);
+      keptIndices.push(i);
       const identifiers = collectAllIdentifiers(stmt);
-      for (const id of identifiers) {
+      for (const id of Array.from(identifiers)) {
         liveVars.add(id);
       }
       continue;
@@ -1045,21 +1048,31 @@ function eliminateDeadCode(program2) {
       const name = stmt[1];
       const value = stmt[2];
       if (liveVars.has(name)) {
-        keptStatements.push(stmt);
+        keptIndices.push(i);
         const identifiers = collectAllIdentifiers(value);
-        for (const id of identifiers) {
+        for (const id of Array.from(identifiers)) {
           liveVars.add(id);
         }
       }
     } else {
-      keptStatements.push(stmt);
+      keptIndices.push(i);
       const identifiers = collectAllIdentifiers(stmt);
-      for (const id of identifiers) {
+      for (const id of Array.from(identifiers)) {
         liveVars.add(id);
       }
     }
   }
-  return program(keptStatements.reverse());
+  const keptStatements = [];
+  for (let i = keptIndices.length - 1;i >= 0; i--) {
+    const idx = keptIndices[i];
+    if (idx !== undefined) {
+      const stmt = statements[idx];
+      if (stmt) {
+        keptStatements.push(stmt);
+      }
+    }
+  }
+  return program(keptStatements);
 }
 function optimize(node) {
   const folded = visit(node, {
@@ -1127,6 +1140,248 @@ function optimize(node) {
   }
   return folded;
 }
+
+// src/jit.ts
+function compile(input) {
+  const parsedAst = typeof input === "string" ? parse(input) : input;
+  const ast = optimize(parsedAst);
+  const jsCode = generateJavaScript(ast);
+  const fullCode = `${HELPER_FUNCTIONS}
+
+${jsCode}`;
+  const fn = new Function("__context", fullCode);
+  return {
+    execute: (context = {}) => {
+      return fn(context);
+    },
+    source: fullCode
+  };
+}
+var HELPER_FUNCTIONS = `
+// Helper function for throwing errors (avoids string concatenation overhead)
+function __throw(msg) { throw new Error(msg); }
+
+// Temporary variables for optimized operations
+let __r;      // For division/modulo right operand
+let __fn;     // For function lookup
+let __val;    // For assignment value
+`.trim();
+function generateJavaScript(node) {
+  const lines = [];
+  const assignedVars = collectAssignedVariables(node);
+  const referencedVars = collectAllIdentifiers(node);
+  const literalAssignments = collectLiteralAssignments(node);
+  lines.push("// Context accessors");
+  lines.push("const __ext = __context.variables || {};");
+  lines.push("const __fns = __context.functions || {};");
+  lines.push("const __extKeys = new Set(Object.keys(__ext));");
+  lines.push("");
+  const allVars = new Set([
+    ...Array.from(assignedVars),
+    ...Array.from(referencedVars)
+  ]);
+  if (allVars.size > 0) {
+    lines.push("// Variable declarations");
+    for (const name of Array.from(allVars)) {
+      const literalValue = literalAssignments.get(name);
+      if (literalValue !== undefined) {
+        lines.push(`let ${name} = __ext.${name} ?? ${literalValue};`);
+      } else {
+        lines.push(`let ${name} = __ext.${name};`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("// Execute program");
+  const code = compileNode(node, literalAssignments);
+  lines.push(`return ${code};`);
+  return lines.join(`
+`);
+}
+function collectAssignedVariables(node) {
+  const names = new Set;
+  visit(node, {
+    Program: (n, recurse) => {
+      for (const stmt of n[1]) {
+        recurse(stmt);
+      }
+    },
+    NumberLiteral: () => {},
+    Identifier: () => {},
+    BinaryOp: (n, recurse) => {
+      recurse(n[1]);
+      recurse(n[3]);
+    },
+    UnaryOp: (n, recurse) => {
+      recurse(n[2]);
+    },
+    FunctionCall: (n, recurse) => {
+      for (const arg of n[2]) {
+        recurse(arg);
+      }
+    },
+    Assignment: (n, recurse) => {
+      names.add(n[1]);
+      recurse(n[2]);
+    },
+    ConditionalExpression: (n, recurse) => {
+      recurse(n[1]);
+      recurse(n[2]);
+      recurse(n[3]);
+    }
+  });
+  return names;
+}
+function collectLiteralAssignments(node) {
+  const literals = new Map;
+  const nonLiterals = new Set;
+  visit(node, {
+    Program: (n, recurse) => {
+      for (const stmt of n[1]) {
+        recurse(stmt);
+      }
+    },
+    NumberLiteral: () => {},
+    Identifier: () => {},
+    BinaryOp: (n, recurse) => {
+      recurse(n[1]);
+      recurse(n[3]);
+    },
+    UnaryOp: (n, recurse) => {
+      recurse(n[2]);
+    },
+    FunctionCall: (n, recurse) => {
+      for (const arg of n[2]) {
+        recurse(arg);
+      }
+    },
+    Assignment: (n, recurse) => {
+      const name = n[1];
+      const value = n[2];
+      if (literals.has(name) || nonLiterals.has(name)) {
+        literals.delete(name);
+        nonLiterals.add(name);
+        return;
+      }
+      if (value[0] === 1 /* NumberLiteral */) {
+        const num = value[1];
+        if (Number.isNaN(num)) {
+          literals.set(name, "NaN");
+        } else if (!Number.isFinite(num)) {
+          literals.set(name, num > 0 ? "Infinity" : "-Infinity");
+        } else {
+          literals.set(name, String(num));
+        }
+      } else {
+        nonLiterals.add(name);
+        recurse(value);
+      }
+    },
+    ConditionalExpression: (n, recurse) => {
+      recurse(n[1]);
+      recurse(n[2]);
+      recurse(n[3]);
+    }
+  });
+  return literals;
+}
+function compileNode(node, literalAssignments = new Map) {
+  const compileIdentifier = (name) => {
+    if (literalAssignments.has(name)) {
+      return name;
+    }
+    return `(${name} !== undefined ? ${name} : __throw('Undefined variable: ${name}'))`;
+  };
+  return visit(node, {
+    Program: (n, recurse) => {
+      const statements = n[1];
+      if (statements.length === 0) {
+        return "0";
+      }
+      if (statements.length === 1) {
+        const stmt = statements[0];
+        return stmt ? recurse(stmt) : "0";
+      }
+      const stmts = statements.map(recurse);
+      return `(${stmts.join(", ")})`;
+    },
+    NumberLiteral: (n) => {
+      const value = n[1];
+      if (Number.isNaN(value))
+        return "NaN";
+      if (!Number.isFinite(value)) {
+        return value > 0 ? "Infinity" : "-Infinity";
+      }
+      return String(value);
+    },
+    Identifier: (n) => {
+      const name = n[1];
+      return compileIdentifier(name);
+    },
+    BinaryOp: (n, recurse) => {
+      const left = recurse(n[1]);
+      const operator = n[2];
+      const right = recurse(n[3]);
+      switch (operator) {
+        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)`;
+        case "/":
+          return `((__r = ${right}) === 0 && __throw('Division by zero'), ${left} / __r)`;
+        case "%":
+          return `((__r = ${right}) === 0 && __throw('Modulo by zero'), ${left} % __r)`;
+        default:
+          return `(${left} ${operator} ${right})`;
+      }
+    },
+    UnaryOp: (n, recurse) => {
+      const operator = n[1];
+      const arg = recurse(n[2]);
+      if (operator === "-") {
+        return `(-${arg})`;
+      }
+      if (operator === "!") {
+        return `(${arg} === 0 ? 1 : 0)`;
+      }
+      throw new Error(`Unknown unary operator: ${operator}`);
+    },
+    FunctionCall: (n, recurse) => {
+      const name = n[1];
+      const args = n[2].map(recurse);
+      const argsStr = args.length > 0 ? args.join(", ") : "";
+      return `((__fn = __fns.${name}) === undefined ? __throw('Undefined function: ${name}') : typeof __fn !== 'function' ? __throw('${name} is not a function') : __fn(${argsStr}))`;
+    },
+    Assignment: (n, recurse) => {
+      const name = n[1];
+      if (literalAssignments.has(name)) {
+        return name;
+      }
+      const value = recurse(n[2]);
+      return `((__val = ${value}), (__extKeys.has('${name}') ? ${name} : (${name} = __val)))`;
+    },
+    ConditionalExpression: (n, recurse) => {
+      const condition = recurse(n[1]);
+      const consequent = recurse(n[2]);
+      const alternate = recurse(n[3]);
+      return `(${condition} !== 0 ? ${consequent} : ${alternate})`;
+    }
+  });
+}
 // src/stdlib/datetime.ts
 var exports_datetime = {};
 __export(exports_datetime, {
@@ -1347,6 +1602,7 @@ export {
   evaluate,
   defaultContext,
   exports_datetime as datetime,
+  compile,
   exports_ast as ast,
   NodeKind
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "littlewing",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "A minimal, high-performance arithmetic expression language with lexer, parser, and executor. Optimized for browsers with zero dependencies and type-safe execution.",
 	"keywords": [
 		"arithmetic",