littlewing 2.1.1 → 2.3.1

package/dist/index.js

@@ -16,6 +16,7 @@ var __export = (target, all) => {
 // src/ast.ts
 var exports_ast = {};
 __export(exports_ast, {
+  visit: () => visit,
   unaryOp: () => unaryOp,
   subtract: () => subtract,
   string: () => string,
@@ -86,6 +87,43 @@ var NodeKind;
   NodeKind2[NodeKind2["PipeExpression"] = 14] = "PipeExpression";
   NodeKind2[NodeKind2["Placeholder"] = 15] = "Placeholder";
 })(NodeKind ||= {});
+function visit(node, visitor) {
+  const recurse = (child) => visit(child, visitor);
+  switch (node.kind) {
+    case 0 /* Program */:
+      return visitor.Program(node, recurse);
+    case 1 /* NumberLiteral */:
+      return visitor.NumberLiteral(node, recurse);
+    case 8 /* StringLiteral */:
+      return visitor.StringLiteral(node, recurse);
+    case 9 /* BooleanLiteral */:
+      return visitor.BooleanLiteral(node, recurse);
+    case 10 /* ArrayLiteral */:
+      return visitor.ArrayLiteral(node, recurse);
+    case 2 /* Identifier */:
+      return visitor.Identifier(node, recurse);
+    case 3 /* BinaryOp */:
+      return visitor.BinaryOp(node, recurse);
+    case 4 /* UnaryOp */:
+      return visitor.UnaryOp(node, recurse);
+    case 5 /* FunctionCall */:
+      return visitor.FunctionCall(node, recurse);
+    case 6 /* Assignment */:
+      return visitor.Assignment(node, recurse);
+    case 7 /* IfExpression */:
+      return visitor.IfExpression(node, recurse);
+    case 11 /* ForExpression */:
+      return visitor.ForExpression(node, recurse);
+    case 12 /* IndexAccess */:
+      return visitor.IndexAccess(node, recurse);
+    case 13 /* RangeExpression */:
+      return visitor.RangeExpression(node, recurse);
+    case 14 /* PipeExpression */:
+      return visitor.PipeExpression(node, recurse);
+    case 15 /* Placeholder */:
+      return visitor.Placeholder(node, recurse);
+  }
+}
 function isProgram(node) {
   return node.kind === 0 /* Program */;
 }
@@ -143,8 +181,10 @@ function number(value) {
 function string(value) {
   return { kind: 8 /* StringLiteral */, value };
 }
+var TRUE_LITERAL = { kind: 9 /* BooleanLiteral */, value: true };
+var FALSE_LITERAL = { kind: 9 /* BooleanLiteral */, value: false };
 function boolean(value) {
-  return { kind: 9 /* BooleanLiteral */, value };
+  return value ? TRUE_LITERAL : FALSE_LITERAL;
 }
 function array(elements) {
   return { kind: 10 /* ArrayLiteral */, elements };
@@ -191,8 +231,9 @@ function rangeExpr(start, end, inclusive) {
 function pipeExpr(value, name, args) {
   return { kind: 14 /* PipeExpression */, value, name, args };
 }
+var PLACEHOLDER_SINGLETON = { kind: 15 /* Placeholder */ };
 function placeholder() {
-  return { kind: 15 /* Placeholder */ };
+  return PLACEHOLDER_SINGLETON;
 }
 function add(left, right) {
   return binaryOp(left, "+", right);
@@ -281,50 +322,6 @@ function getNodeName(node) {
   }
 }
 
-// src/visitor.ts
-function visit(node, visitor) {
-  return visitPartial(node, visitor, (node2) => {
-    throw new Error(`No handler for node type: ${getNodeName(node2)}`);
-  });
-}
-function visitPartial(node, visitor, defaultHandler) {
-  const recurse = (n) => visitPartial(n, visitor, defaultHandler);
-  switch (node.kind) {
-    case 0 /* Program */:
-      return visitor.Program ? visitor.Program(node, recurse) : defaultHandler(node, recurse);
-    case 1 /* NumberLiteral */:
-      return visitor.NumberLiteral ? visitor.NumberLiteral(node, recurse) : defaultHandler(node, recurse);
-    case 8 /* StringLiteral */:
-      return visitor.StringLiteral ? visitor.StringLiteral(node, recurse) : defaultHandler(node, recurse);
-    case 9 /* BooleanLiteral */:
-      return visitor.BooleanLiteral ? visitor.BooleanLiteral(node, recurse) : defaultHandler(node, recurse);
-    case 10 /* ArrayLiteral */:
-      return visitor.ArrayLiteral ? visitor.ArrayLiteral(node, recurse) : defaultHandler(node, recurse);
-    case 2 /* Identifier */:
-      return visitor.Identifier ? visitor.Identifier(node, recurse) : defaultHandler(node, recurse);
-    case 3 /* BinaryOp */:
-      return visitor.BinaryOp ? visitor.BinaryOp(node, recurse) : defaultHandler(node, recurse);
-    case 4 /* UnaryOp */:
-      return visitor.UnaryOp ? visitor.UnaryOp(node, recurse) : defaultHandler(node, recurse);
-    case 5 /* FunctionCall */:
-      return visitor.FunctionCall ? visitor.FunctionCall(node, recurse) : defaultHandler(node, recurse);
-    case 6 /* Assignment */:
-      return visitor.Assignment ? visitor.Assignment(node, recurse) : defaultHandler(node, recurse);
-    case 7 /* IfExpression */:
-      return visitor.IfExpression ? visitor.IfExpression(node, recurse) : defaultHandler(node, recurse);
-    case 11 /* ForExpression */:
-      return visitor.ForExpression ? visitor.ForExpression(node, recurse) : defaultHandler(node, recurse);
-    case 12 /* IndexAccess */:
-      return visitor.IndexAccess ? visitor.IndexAccess(node, recurse) : defaultHandler(node, recurse);
-    case 13 /* RangeExpression */:
-      return visitor.RangeExpression ? visitor.RangeExpression(node, recurse) : defaultHandler(node, recurse);
-    case 14 /* PipeExpression */:
-      return visitor.PipeExpression ? visitor.PipeExpression(node, recurse) : defaultHandler(node, recurse);
-    case 15 /* Placeholder */:
-      return visitor.Placeholder ? visitor.Placeholder(node, recurse) : defaultHandler(node, recurse);
-  }
-}
-
 // src/analyzer.ts
 function extractInputVariables(ast) {
   const inputVars = new Set;
@@ -341,78 +338,139 @@ function extractInputVariables(ast) {
 function extractAssignedVariables(ast) {
   const seen = new Set;
   const names = [];
-  visitPartial(ast, {
-    Program: (n, recurse) => {
-      for (const statement of n.statements) {
-        recurse(statement);
-      }
-    },
-    Assignment: (n, recurse) => {
-      if (!seen.has(n.name)) {
-        seen.add(n.name);
-        names.push(n.name);
+  collectAssignedVariables(ast, seen, names);
+  return names;
+}
+function collectAssignedVariables(node, seen, names) {
+  switch (node.kind) {
+    case 0 /* Program */:
+      for (const statement of node.statements) {
+        collectAssignedVariables(statement, seen, names);
       }
-      recurse(n.value);
-    },
-    IfExpression: (n, recurse) => {
-      recurse(n.condition);
-      recurse(n.consequent);
-      recurse(n.alternate);
-    },
-    ForExpression: (n, recurse) => {
-      recurse(n.iterable);
-      if (n.guard)
-        recurse(n.guard);
-      if (n.accumulator)
-        recurse(n.accumulator.initial);
-      recurse(n.body);
-    },
-    IndexAccess: (n, recurse) => {
-      recurse(n.object);
-      recurse(n.index);
-    },
-    RangeExpression: (n, recurse) => {
-      recurse(n.start);
-      recurse(n.end);
-    },
-    PipeExpression: (n, recurse) => {
-      recurse(n.value);
-      for (const arg of n.args) {
-        recurse(arg);
+      break;
+    case 6 /* Assignment */:
+      if (!seen.has(node.name)) {
+        seen.add(node.name);
+        names.push(node.name);
       }
-    }
-  }, () => {});
-  return names;
+      collectAssignedVariables(node.value, seen, names);
+      break;
+    case 3 /* BinaryOp */:
+      collectAssignedVariables(node.left, seen, names);
+      collectAssignedVariables(node.right, seen, names);
+      break;
+    case 4 /* UnaryOp */:
+      collectAssignedVariables(node.argument, seen, names);
+      break;
+    case 10 /* ArrayLiteral */:
+      for (const e of node.elements)
+        collectAssignedVariables(e, seen, names);
+      break;
+    case 5 /* FunctionCall */:
+      for (const a of node.args)
+        collectAssignedVariables(a, seen, names);
+      break;
+    case 7 /* IfExpression */:
+      collectAssignedVariables(node.condition, seen, names);
+      collectAssignedVariables(node.consequent, seen, names);
+      collectAssignedVariables(node.alternate, seen, names);
+      break;
+    case 11 /* ForExpression */:
+      collectAssignedVariables(node.iterable, seen, names);
+      if (node.guard)
+        collectAssignedVariables(node.guard, seen, names);
+      if (node.accumulator)
+        collectAssignedVariables(node.accumulator.initial, seen, names);
+      collectAssignedVariables(node.body, seen, names);
+      break;
+    case 12 /* IndexAccess */:
+      collectAssignedVariables(node.object, seen, names);
+      collectAssignedVariables(node.index, seen, names);
+      break;
+    case 13 /* RangeExpression */:
+      collectAssignedVariables(node.start, seen, names);
+      collectAssignedVariables(node.end, seen, names);
+      break;
+    case 14 /* PipeExpression */:
+      collectAssignedVariables(node.value, seen, names);
+      for (const arg of node.args)
+        collectAssignedVariables(arg, seen, names);
+      break;
+    case 1 /* NumberLiteral */:
+    case 8 /* StringLiteral */:
+    case 9 /* BooleanLiteral */:
+    case 2 /* Identifier */:
+    case 15 /* Placeholder */:
+      break;
+  }
 }
 function containsExternalReference(node, boundVars) {
-  return visit(node, {
-    Program: (n, recurse) => n.statements.some(recurse),
-    NumberLiteral: () => false,
-    StringLiteral: () => false,
-    BooleanLiteral: () => false,
-    Identifier: (n) => !boundVars.has(n.name),
-    ArrayLiteral: (n, recurse) => n.elements.some(recurse),
-    BinaryOp: (n, recurse) => recurse(n.left) || recurse(n.right),
-    UnaryOp: (n, recurse) => recurse(n.argument),
-    FunctionCall: (n, recurse) => n.args.some(recurse),
-    Assignment: (n, recurse) => recurse(n.value),
-    IfExpression: (n, recurse) => recurse(n.condition) || recurse(n.consequent) || recurse(n.alternate),
-    ForExpression: (n, recurse) => {
+  const recurse = (n) => containsExternalReference(n, boundVars);
+  switch (node.kind) {
+    case 0 /* Program */:
+      return node.statements.some(recurse);
+    case 2 /* Identifier */:
+      return !boundVars.has(node.name);
+    case 10 /* ArrayLiteral */:
+      return node.elements.some(recurse);
+    case 3 /* BinaryOp */:
+      return recurse(node.left) || recurse(node.right);
+    case 4 /* UnaryOp */:
+      return recurse(node.argument);
+    case 5 /* FunctionCall */:
+      return node.args.some(recurse);
+    case 6 /* Assignment */:
+      return recurse(node.value);
+    case 7 /* IfExpression */:
+      return recurse(node.condition) || recurse(node.consequent) || recurse(node.alternate);
+    case 11 /* ForExpression */: {
       const innerBound = new Set(boundVars);
-      innerBound.add(n.variable);
-      if (n.accumulator)
-        innerBound.add(n.accumulator.name);
-      return recurse(n.iterable) || (n.guard ? containsExternalReference(n.guard, innerBound) : false) || (n.accumulator ? recurse(n.accumulator.initial) : false) || containsExternalReference(n.body, innerBound);
-    },
-    IndexAccess: (n, recurse) => recurse(n.object) || recurse(n.index),
-    RangeExpression: (n, recurse) => recurse(n.start) || recurse(n.end),
-    PipeExpression: (n, recurse) => recurse(n.value) || n.args.some(recurse),
-    Placeholder: () => false
-  });
+      innerBound.add(node.variable);
+      if (node.accumulator)
+        innerBound.add(node.accumulator.name);
+      return recurse(node.iterable) || (node.guard ? containsExternalReference(node.guard, innerBound) : false) || (node.accumulator ? recurse(node.accumulator.initial) : false) || containsExternalReference(node.body, innerBound);
+    }
+    case 12 /* IndexAccess */:
+      return recurse(node.object) || recurse(node.index);
+    case 13 /* RangeExpression */:
+      return recurse(node.start) || recurse(node.end);
+    case 14 /* PipeExpression */:
+      return recurse(node.value) || node.args.some(recurse);
+    case 1 /* NumberLiteral */:
+    case 8 /* StringLiteral */:
+    case 9 /* BooleanLiteral */:
+    case 15 /* Placeholder */:
+      return false;
+  }
 }
 function containsVariableReference(node) {
   return containsExternalReference(node, new Set);
 }
+// src/errors.ts
+class ParseError extends Error {
+  start;
+  end;
+  name = "ParseError";
+  constructor(message, start, end) {
+    super(message);
+    this.start = start;
+    this.end = end;
+  }
+}
+function toLineColumn(source, offset) {
+  let line = 1;
+  let column = 1;
+  const clamped = Math.min(offset, source.length);
+  for (let i = 0;i < clamped; i++) {
+    if (source.charCodeAt(i) === 10) {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { line, column };
+}
 // src/lexer.ts
 var KEYWORDS = new Map([
   ["if", 28 /* If */],
@@ -594,7 +652,7 @@ function nextToken(cursor) {
         }
         return [18 /* DotDot */, start, cursor.pos];
       }
-      throw new Error(`Unexpected character '${String.fromCharCode(ch)}' at position ${start}`);
+      throw new ParseError(`Unexpected character '${String.fromCharCode(ch)}'`, start, cursor.pos);
     case 44:
       advance(cursor);
       return [25 /* Comma */, start, cursor.pos];
@@ -607,7 +665,7 @@ function nextToken(cursor) {
         advance(cursor);
         return [16 /* And */, start, cursor.pos];
       }
-      throw new Error(`Unexpected character '${String.fromCharCode(ch)}' at position ${start}`);
+      throw new ParseError(`Unexpected character '${String.fromCharCode(ch)}'`, start, cursor.pos);
     case 124:
       advance(cursor);
       if (peek(cursor) === 124) {
@@ -618,12 +676,13 @@ function nextToken(cursor) {
         advance(cursor);
         return [26 /* Pipe */, start, cursor.pos];
       }
-      throw new Error(`Unexpected character '${String.fromCharCode(ch)}' at position ${start}`);
+      throw new ParseError(`Unexpected character '${String.fromCharCode(ch)}'`, start, cursor.pos);
     case 63:
       advance(cursor);
       return [27 /* Question */, start, cursor.pos];
     default:
-      throw new Error(`Unexpected character '${String.fromCharCode(ch)}' at position ${start}`);
+      advance(cursor);
+      throw new ParseError(`Unexpected character '${String.fromCharCode(ch)}'`, start, cursor.pos);
   }
 }
 function lexString(cursor) {
@@ -640,7 +699,7 @@ function lexString(cursor) {
       cursor.pos++;
     }
   }
-  throw new Error(`Unterminated string at position ${start}`);
+  throw new ParseError("Unterminated string", start, cursor.pos);
 }
 function lexNumber(cursor) {
   const start = cursor.pos;
@@ -789,7 +848,17 @@ function concatenateArrays(a, b) {
 function validateHomogeneousArray(elements) {
   if (elements.length <= 1)
     return;
-  const firstType = typeOf(elements[0]);
+  const first = elements[0];
+  const firstPrimitive = typeof first;
+  if (firstPrimitive === "number" || firstPrimitive === "string" || firstPrimitive === "boolean") {
+    for (let i = 1;i < elements.length; i++) {
+      if (typeof elements[i] !== firstPrimitive) {
+        throw new TypeError(`Heterogeneous array: expected ${firstPrimitive}, got ${typeOf(elements[i])} at index ${i}`);
+      }
+    }
+    return;
+  }
+  const firstType = typeOf(first);
   for (let i = 1;i < elements.length; i++) {
     const elemType = typeOf(elements[i]);
     if (elemType !== firstType) {
@@ -893,13 +962,29 @@ function resolveIndex(target, index) {
     throw new TypeError(`Index must be an integer, got ${index}`);
   }
   if (typeof target === "string") {
-    const codePoints = Array.from(target);
-    const len2 = codePoints.length;
-    const resolved2 = index < 0 ? len2 + index : index;
-    if (resolved2 < 0 || resolved2 >= len2) {
+    if (index >= 0) {
+      let i2 = 0;
+      for (const cp of target) {
+        if (i2 === index)
+          return cp;
+        i2++;
+      }
+      throw new RangeError(`Index ${index} out of bounds for length ${i2}`);
+    }
+    let len2 = 0;
+    for (const _ of target)
+      len2++;
+    const resolved2 = len2 + index;
+    if (resolved2 < 0) {
       throw new RangeError(`Index ${index} out of bounds for length ${len2}`);
     }
-    return codePoints[resolved2];
+    let i = 0;
+    for (const cp of target) {
+      if (i === resolved2)
+        return cp;
+      i++;
+    }
+    throw new RangeError(`Index ${index} out of bounds for length ${len2}`);
   }
   const len = target.length;
   const resolved = index < 0 ? len + index : index;
@@ -919,11 +1004,7 @@ function buildRange(start, end, inclusive) {
     throw new RangeError(`Range start (${start}) must not exceed end (${end})`);
   }
   const limit = inclusive ? end + 1 : end;
-  const result = [];
-  for (let i = start;i < limit; i++) {
-    result.push(i);
-  }
-  return result;
+  return Array.from({ length: limit - start }, (_, i) => start + i);
 }
 function getOperatorPrecedence(operator) {
   switch (operator) {
@@ -953,69 +1034,75 @@ function getOperatorPrecedence(operator) {
 }
 function collectAllIdentifiers(node) {
   const identifiers = new Set;
-  visit(node, {
-    Program: (n, recurse) => {
-      for (const stmt of n.statements) {
-        recurse(stmt);
-      }
-    },
-    NumberLiteral: () => {},
-    StringLiteral: () => {},
-    BooleanLiteral: () => {},
-    ArrayLiteral: (n, recurse) => {
-      for (const elem of n.elements) {
-        recurse(elem);
-      }
-    },
-    Identifier: (n) => {
-      identifiers.add(n.name);
-    },
-    BinaryOp: (n, recurse) => {
-      recurse(n.left);
-      recurse(n.right);
-    },
-    UnaryOp: (n, recurse) => {
-      recurse(n.argument);
-    },
-    FunctionCall: (n, recurse) => {
-      for (const arg of n.args) {
-        recurse(arg);
-      }
-    },
-    Assignment: (n, recurse) => {
-      recurse(n.value);
-    },
-    IfExpression: (n, recurse) => {
-      recurse(n.condition);
-      recurse(n.consequent);
-      recurse(n.alternate);
-    },
-    ForExpression: (n, recurse) => {
-      recurse(n.iterable);
-      if (n.guard)
-        recurse(n.guard);
-      if (n.accumulator)
-        recurse(n.accumulator.initial);
-      recurse(n.body);
-    },
-    IndexAccess: (n, recurse) => {
-      recurse(n.object);
-      recurse(n.index);
-    },
-    RangeExpression: (n, recurse) => {
-      recurse(n.start);
-      recurse(n.end);
-    },
-    PipeExpression: (n, recurse) => {
-      recurse(n.value);
-      for (const arg of n.args) {
-        recurse(arg);
-      }
-    },
-    Placeholder: () => {}
-  });
+  collectIdentifiers(node, identifiers, new Set);
   return identifiers;
 }
+function collectIdentifiers(node, ids, boundVars) {
+  switch (node.kind) {
+    case 0 /* Program */:
+      for (const s of node.statements)
+        collectIdentifiers(s, ids, boundVars);
+      break;
+    case 2 /* Identifier */:
+      if (!boundVars.has(node.name))
+        ids.add(node.name);
+      break;
+    case 10 /* ArrayLiteral */:
+      for (const e of node.elements)
+        collectIdentifiers(e, ids, boundVars);
+      break;
+    case 3 /* BinaryOp */:
+      collectIdentifiers(node.left, ids, boundVars);
+      collectIdentifiers(node.right, ids, boundVars);
+      break;
+    case 4 /* UnaryOp */:
+      collectIdentifiers(node.argument, ids, boundVars);
+      break;
+    case 5 /* FunctionCall */:
+      for (const a of node.args)
+        collectIdentifiers(a, ids, boundVars);
+      break;
+    case 6 /* Assignment */:
+      collectIdentifiers(node.value, ids, boundVars);
+      break;
+    case 7 /* IfExpression */:
+      collectIdentifiers(node.condition, ids, boundVars);
+      collectIdentifiers(node.consequent, ids, boundVars);
+      collectIdentifiers(node.alternate, ids, boundVars);
+      break;
+    case 11 /* ForExpression */: {
+      collectIdentifiers(node.iterable, ids, boundVars);
+      if (node.accumulator)
+        collectIdentifiers(node.accumulator.initial, ids, boundVars);
+      const innerBound = new Set(boundVars);
+      innerBound.add(node.variable);
+      if (node.accumulator)
+        innerBound.add(node.accumulator.name);
+      if (node.guard)
+        collectIdentifiers(node.guard, ids, innerBound);
+      collectIdentifiers(node.body, ids, innerBound);
+      break;
+    }
+    case 12 /* IndexAccess */:
+      collectIdentifiers(node.object, ids, boundVars);
+      collectIdentifiers(node.index, ids, boundVars);
+      break;
+    case 13 /* RangeExpression */:
+      collectIdentifiers(node.start, ids, boundVars);
+      collectIdentifiers(node.end, ids, boundVars);
+      break;
+    case 14 /* PipeExpression */:
+      collectIdentifiers(node.value, ids, boundVars);
+      for (const a of node.args)
+        collectIdentifiers(a, ids, boundVars);
+      break;
+    case 1 /* NumberLiteral */:
+    case 8 /* StringLiteral */:
+    case 9 /* BooleanLiteral */:
+    case 15 /* Placeholder */:
+      break;
+  }
+}
 function getTokenPrecedence(kind) {
   switch (kind) {
     case 24 /* Eq */:
@@ -1113,90 +1200,88 @@ function generate(node) {
   return code;
 }
 function generateNode(node) {
-  return visit(node, {
-    Program: generateProgram,
-    NumberLiteral: (n) => {
-      return String(n.value);
-    },
-    StringLiteral: (n) => {
-      return `"${escapeString(n.value)}"`;
-    },
-    BooleanLiteral: (n) => {
-      return n.value ? "true" : "false";
-    },
-    ArrayLiteral: (n, recurse) => {
-      return `[${n.elements.map(recurse).join(", ")}]`;
-    },
-    Identifier: (n) => {
-      return n.name;
-    },
-    BinaryOp: (n, recurse) => {
-      const left = recurse(n.left);
-      const right = recurse(n.right);
-      const opPrec = getOperatorPrecedence(n.operator);
-      const leftNeedsParens = needsParens(n.left, n.operator, true) || n.operator === "^" && isUnaryOp(n.left) || isIfExpression(n.left) || isForExpression(n.left) || isAssignment(n.left) || isRangeExpression(n.left) && opPrec >= 7;
+  const recurse = generateNode;
+  switch (node.kind) {
+    case 0 /* Program */:
+      return generateProgram(node, recurse);
+    case 1 /* NumberLiteral */:
+      return String(node.value);
+    case 8 /* StringLiteral */:
+      return `"${escapeString(node.value)}"`;
+    case 9 /* BooleanLiteral */:
+      return node.value ? "true" : "false";
+    case 10 /* ArrayLiteral */:
+      return `[${node.elements.map(recurse).join(", ")}]`;
+    case 2 /* Identifier */:
+      return node.name;
+    case 3 /* BinaryOp */: {
+      const left = recurse(node.left);
+      const right = recurse(node.right);
+      const opPrec = getOperatorPrecedence(node.operator);
+      const leftNeedsParens = needsParens(node.left, node.operator, true) || node.operator === "^" && isUnaryOp(node.left) || isIfExpression(node.left) || isForExpression(node.left) || isAssignment(node.left) || isRangeExpression(node.left) && opPrec >= 7;
       const leftCode = leftNeedsParens ? `(${left})` : left;
-      const rightNeedsParens = needsParens(n.right, n.operator, false) || isPipeExpression(n.right) || isAssignment(n.right) || isRangeExpression(n.right) && opPrec >= 6;
+      const rightNeedsParens = needsParens(node.right, node.operator, false) || isPipeExpression(node.right) || isAssignment(node.right) || isRangeExpression(node.right) && opPrec >= 6;
       const rightCode = rightNeedsParens ? `(${right})` : right;
-      return `${leftCode} ${n.operator} ${rightCode}`;
-    },
-    UnaryOp: (n, recurse) => {
-      const arg = recurse(n.argument);
-      const parensNeeded = isBinaryOp(n.argument) || isAssignment(n.argument) || isPipeExpression(n.argument) || isRangeExpression(n.argument);
+      return `${leftCode} ${node.operator} ${rightCode}`;
+    }
+    case 4 /* UnaryOp */: {
+      const arg = recurse(node.argument);
+      const parensNeeded = isBinaryOp(node.argument) || isAssignment(node.argument) || isPipeExpression(node.argument) || isRangeExpression(node.argument);
       const argCode = parensNeeded ? `(${arg})` : arg;
-      return `${n.operator}${argCode}`;
-    },
-    FunctionCall: (n, recurse) => {
-      const argsCode = n.args.map(recurse).join(", ");
-      return `${n.name}(${argsCode})`;
-    },
-    Assignment: (n, recurse) => {
-      const value = recurse(n.value);
-      return `${n.name} = ${value}`;
-    },
-    IfExpression: (n, recurse) => {
-      const condition = recurse(n.condition);
-      const consequent = recurse(n.consequent);
-      const alternate = recurse(n.alternate);
+      return `${node.operator}${argCode}`;
+    }
+    case 5 /* FunctionCall */: {
+      const argsCode = node.args.map(recurse).join(", ");
+      return `${node.name}(${argsCode})`;
+    }
+    case 6 /* Assignment */: {
+      const value = recurse(node.value);
+      return `${node.name} = ${value}`;
+    }
+    case 7 /* IfExpression */: {
+      const condition = recurse(node.condition);
+      const consequent = recurse(node.consequent);
+      const alternate = recurse(node.alternate);
       return `if ${condition} then ${consequent} else ${alternate}`;
-    },
-    ForExpression: (n, recurse) => {
-      const parts = [`for ${n.variable} in ${recurse(n.iterable)}`];
-      if (n.guard) {
-        parts.push(`when ${recurse(n.guard)}`);
+    }
+    case 11 /* ForExpression */: {
+      const parts = [`for ${node.variable} in ${recurse(node.iterable)}`];
+      if (node.guard) {
+        parts.push(`when ${recurse(node.guard)}`);
       }
-      if (n.accumulator) {
-        parts.push(`into ${n.accumulator.name} = ${recurse(n.accumulator.initial)}`);
+      if (node.accumulator) {
+        parts.push(`into ${node.accumulator.name} = ${recurse(node.accumulator.initial)}`);
       }
-      parts.push(`then ${recurse(n.body)}`);
+      parts.push(`then ${recurse(node.body)}`);
       return parts.join(" ");
-    },
-    IndexAccess: (n, recurse) => {
-      const object = recurse(n.object);
-      const index = recurse(n.index);
-      const needsParens2 = isBinaryOp(n.object) || isUnaryOp(n.object) || isAssignment(n.object) || isRangeExpression(n.object) || isPipeExpression(n.object);
-      const objectCode = needsParens2 ? `(${object})` : object;
+    }
+    case 12 /* IndexAccess */: {
+      const object = recurse(node.object);
+      const index = recurse(node.index);
+      const objNeedsParens = isBinaryOp(node.object) || isUnaryOp(node.object) || isAssignment(node.object) || isRangeExpression(node.object) || isPipeExpression(node.object);
+      const objectCode = objNeedsParens ? `(${object})` : object;
       return `${objectCode}[${index}]`;
-    },
-    RangeExpression: (n, recurse) => {
-      const start = recurse(n.start);
-      const end = recurse(n.end);
-      const op = n.inclusive ? "..=" : "..";
-      const startNeedsParens = isBinaryOp(n.start) || isRangeExpression(n.start) || isIfExpression(n.start) || isForExpression(n.start) || isAssignment(n.start);
-      const endNeedsParens = isBinaryOp(n.end) || isRangeExpression(n.end) || isPipeExpression(n.end) || isAssignment(n.end);
+    }
+    case 13 /* RangeExpression */: {
+      const start = recurse(node.start);
+      const end = recurse(node.end);
+      const op = node.inclusive ? "..=" : "..";
+      const startNeedsParens = isBinaryOp(node.start) || isRangeExpression(node.start) || isIfExpression(node.start) || isForExpression(node.start) || isAssignment(node.start);
+      const endNeedsParens = isBinaryOp(node.end) || isRangeExpression(node.end) || isPipeExpression(node.end) || isAssignment(node.end);
       const startCode = startNeedsParens ? `(${start})` : start;
       const endCode = endNeedsParens ? `(${end})` : end;
       return `${startCode}${op}${endCode}`;
-    },
-    PipeExpression: (n, recurse) => {
-      const value = recurse(n.value);
-      const argsCode = n.args.map(recurse).join(", ");
-      const valueNeedsParens = isAssignment(n.value) || isIfExpression(n.value) || isForExpression(n.value);
+    }
+    case 14 /* PipeExpression */: {
+      const value = recurse(node.value);
+      const argsCode = node.args.map(recurse).join(", ");
+      const valueNeedsParens = isAssignment(node.value) || isIfExpression(node.value) || isForExpression(node.value);
       const valueCode = valueNeedsParens ? `(${value})` : value;
-      return `${valueCode} |> ${n.name}(${argsCode})`;
-    },
-    Placeholder: () => "?"
-  });
+      return `${valueCode} |> ${node.name}(${argsCode})`;
+    }
+    case 15 /* Placeholder */:
+      return "?";
+  }
 }
 // src/parser.ts
 var BINARY_OPERATOR_TOKENS = new Set([
@@ -1230,13 +1315,13 @@ function parse(source) {
     statements.push(parseExpression(state, 0));
   }
   if (statements.length === 0) {
-    throw new Error("Empty program");
+    throw new ParseError("Empty program", 0, 0);
   }
   const annotated = attachComments(source, statements, statementOffsets, cursor.comments);
   if (annotated.statements.length === 1 && !annotated.programTrailing) {
     const stmt = annotated.statements[0];
     if (stmt === undefined) {
-      throw new Error("Unexpected empty statements array");
+      throw new ParseError("Unexpected empty statements array", 0, 0);
     }
     return stmt;
   }
@@ -1346,7 +1431,7 @@ function parseExpression(state, minPrecedence) {
       advance2(state);
       const index = parseExpression(state, 0);
       if (peekKind(state) !== 23 /* RBracket */) {
-        throw new Error("Expected closing bracket");
+        throw new ParseError("Expected closing bracket", state.currentToken[1], state.currentToken[2]);
       }
       advance2(state);
       left = indexAccess(left, index);
@@ -1377,7 +1462,7 @@ function parsePrefix(state) {
     advance2(state);
     const expr = parseExpression(state, 0);
     if (peekKind(state) !== 21 /* RParen */) {
-      throw new Error("Expected closing parenthesis");
+      throw new ParseError("Expected closing parenthesis", state.currentToken[1], state.currentToken[2]);
     }
     advance2(state);
     return expr;
@@ -1393,7 +1478,7 @@ function parsePrefix(state) {
       }
     }
     if (peekKind(state) !== 23 /* RBracket */) {
-      throw new Error("Expected closing bracket");
+      throw new ParseError("Expected closing bracket", state.currentToken[1], state.currentToken[2]);
     }
     advance2(state);
     return array(elements);
@@ -1402,12 +1487,12 @@ function parsePrefix(state) {
     advance2(state);
     const condition = parseExpression(state, 0);
     if (peekKind(state) !== 29 /* Then */) {
-      throw new Error('Expected "then" in if expression');
+      throw new ParseError('Expected "then" in if expression', state.currentToken[1], state.currentToken[2]);
     }
     advance2(state);
     const consequent = parseExpression(state, 0);
     if (peekKind(state) !== 30 /* Else */) {
-      throw new Error('Expected "else" in if expression');
+      throw new ParseError('Expected "else" in if expression', state.currentToken[1], state.currentToken[2]);
     }
     advance2(state);
     const alternate = parseExpression(state, 0);
@@ -1416,12 +1501,12 @@ function parsePrefix(state) {
   if (tokenKind === 31 /* For */) {
     advance2(state);
     if (peekKind(state) !== 1 /* Identifier */) {
-      throw new Error('Expected identifier after "for"');
+      throw new ParseError('Expected identifier after "for"', state.currentToken[1], state.currentToken[2]);
     }
     const variableName = readText(state.cursor, state.currentToken);
     advance2(state);
     if (peekKind(state) !== 32 /* In */) {
-      throw new Error('Expected "in" in for expression');
+      throw new ParseError('Expected "in" in for expression', state.currentToken[1], state.currentToken[2]);
     }
     advance2(state);
     const iterable = parseExpression(state, 0);
@@ -1434,19 +1519,19 @@ function parsePrefix(state) {
     if (peekKind(state) === 34 /* Into */) {
       advance2(state);
       if (peekKind(state) !== 1 /* Identifier */) {
-        throw new Error('Expected identifier after "into"');
+        throw new ParseError('Expected identifier after "into"', state.currentToken[1], state.currentToken[2]);
       }
       const accName = readText(state.cursor, state.currentToken);
       advance2(state);
       if (peekKind(state) !== 24 /* Eq */) {
-        throw new Error('Expected "=" after accumulator name');
+        throw new ParseError('Expected "=" after accumulator name', state.currentToken[1], state.currentToken[2]);
       }
       advance2(state);
       const initial = parseExpression(state, 0);
       accumulator = { name: accName, initial };
     }
     if (peekKind(state) !== 29 /* Then */) {
-      throw new Error('Expected "then" in for expression');
+      throw new ParseError('Expected "then" in for expression', state.currentToken[1], state.currentToken[2]);
     }
     advance2(state);
     const body = parseExpression(state, 0);
@@ -1478,7 +1563,7 @@ function parsePrefix(state) {
       advance2(state);
       const args = parseFunctionArguments(state);
       if (peekKind(state) !== 21 /* RParen */) {
-        throw new Error("Expected closing parenthesis");
+        throw new ParseError("Expected closing parenthesis", state.currentToken[1], state.currentToken[2]);
       }
       advance2(state);
       return functionCall(name, args);
@@ -1487,13 +1572,13 @@ function parsePrefix(state) {
   }
   const token = state.currentToken;
   const tokenText = readText(state.cursor, token);
-  throw new Error(`Unexpected token: ${tokenText}`);
+  throw new ParseError(`Unexpected token: ${tokenText}`, token[1], token[2]);
 }
 function parseInfix(state, left, precedence) {
   const tokenKind = peekKind(state);
   if (tokenKind === 24 /* Eq */) {
     if (left.kind !== 2 /* Identifier */) {
-      throw new Error("Invalid assignment target");
+      throw new ParseError("Invalid assignment target", state.currentToken[1], state.currentToken[2]);
     }
     const identName = left.name;
     advance2(state);
@@ -1509,17 +1594,17 @@ function parseInfix(state, left, precedence) {
   if (tokenKind === 26 /* Pipe */) {
     advance2(state);
     if (peekKind(state) !== 1 /* Identifier */) {
-      throw new Error("Expected function name after |>");
+      throw new ParseError("Expected function name after |>", state.currentToken[1], state.currentToken[2]);
     }
     const name = readText(state.cursor, state.currentToken);
     advance2(state);
     if (peekKind(state) !== 20 /* LParen */) {
-      throw new Error("Expected ( after function name in pipe expression");
+      throw new ParseError("Expected ( after function name in pipe expression", state.currentToken[1], state.currentToken[2]);
     }
     advance2(state);
     const args = parsePipeArguments(state);
     if (peekKind(state) !== 21 /* RParen */) {
-      throw new Error("Expected closing parenthesis");
+      throw new ParseError("Expected closing parenthesis", state.currentToken[1], state.currentToken[2]);
     }
     advance2(state);
     let hasPlaceholder = false;
@@ -1530,7 +1615,7 @@ function parseInfix(state, left, precedence) {
       }
     }
     if (!hasPlaceholder) {
-      throw new Error("Pipe expression requires at least one ? placeholder");
+      throw new ParseError("Pipe expression requires at least one ? placeholder", state.currentToken[1], state.currentToken[2]);
     }
     return pipeExpr(left, name, args);
   }
@@ -1541,7 +1626,7 @@ function parseInfix(state, left, precedence) {
     const right = parseExpression(state, isRightAssociative ? precedence : precedence + 1);
     return binaryOp(left, operator, right);
   }
-  throw new Error("Unexpected token in infix position");
+  throw new ParseError("Unexpected token in infix position", state.currentToken[1], state.currentToken[2]);
 }
 function parseFunctionArguments(state) {
   if (peekKind(state) === 21 /* RParen */) {
@@ -1586,198 +1671,224 @@ function advance2(state) {
 }
 
 // src/interpreter.ts
-function evaluateNode(node, context, variables, externalVariables) {
-  return visit(node, {
-    Program: (n, recurse) => {
-      let result = 0;
-      for (const statement of n.statements) {
-        result = recurse(statement);
-      }
-      return result;
-    },
-    NumberLiteral: (n) => n.value,
-    StringLiteral: (n) => n.value,
-    BooleanLiteral: (n) => n.value,
-    ArrayLiteral: (n, recurse) => {
-      const elements = n.elements.map(recurse);
-      validateHomogeneousArray(elements);
-      return elements;
-    },
-    Identifier: (n) => {
-      const value = variables.get(n.name);
-      if (value === undefined) {
-        throw new Error(`Undefined variable: ${n.name}`);
-      }
-      return value;
-    },
-    BinaryOp: (n, recurse) => {
-      if (n.operator === "&&") {
-        const left2 = recurse(n.left);
-        assertBoolean(left2, "Operator '&&'", "left");
-        if (!left2)
-          return false;
-        const right2 = recurse(n.right);
-        assertBoolean(right2, "Operator '&&'", "right");
-        return right2;
-      }
-      if (n.operator === "||") {
-        const left2 = recurse(n.left);
-        assertBoolean(left2, "Operator '||'", "left");
-        if (left2)
-          return true;
-        const right2 = recurse(n.right);
-        assertBoolean(right2, "Operator '||'", "right");
-        return right2;
+function run(input, context = {}) {
+  const node = typeof input === "string" ? parse(input) : input;
+  const variables = new Map;
+  const externalVariables = new Set;
+  const vars = context.variables;
+  if (vars) {
+    for (const key of Object.keys(vars)) {
+      variables.set(key, vars[key]);
+      externalVariables.add(key);
+    }
+  }
+  const value = evalNode(node);
+  return { value, variables };
+  function evalNode(node2) {
+    switch (node2.kind) {
+      case 0 /* Program */: {
+        let result = 0;
+        for (const statement of node2.statements) {
+          result = evalNode(statement);
+        }
+        return result;
       }
-      const left = recurse(n.left);
-      const right = recurse(n.right);
-      return evaluateBinaryOperation(n.operator, left, right);
-    },
-    UnaryOp: (n, recurse) => {
-      const arg = recurse(n.argument);
-      if (n.operator === "-") {
-        assertNumber(arg, "Operator '-' (unary)");
-        return -arg;
+      case 1 /* NumberLiteral */:
+        return node2.value;
+      case 8 /* StringLiteral */:
+        return node2.value;
+      case 9 /* BooleanLiteral */:
+        return node2.value;
+      case 10 /* ArrayLiteral */: {
+        const elems = node2.elements;
+        const elements = [];
+        for (let i = 0;i < elems.length; i++) {
+          elements.push(evalNode(elems[i]));
+        }
+        validateHomogeneousArray(elements);
+        return elements;
       }
-      if (n.operator === "!") {
-        assertBoolean(arg, "Operator '!'");
-        return !arg;
+      case 2 /* Identifier */: {
+        const value2 = variables.get(node2.name);
+        if (value2 === undefined) {
+          throw new Error(`Undefined variable: ${node2.name}`);
+        }
+        return value2;
       }
-      throw new Error(`Unknown unary operator: ${String(n.operator)}`);
-    },
-    FunctionCall: (n, recurse) => {
-      const fn = context.functions?.[n.name];
-      if (fn === undefined) {
-        throw new Error(`Undefined function: ${n.name}`);
+      case 3 /* BinaryOp */: {
+        if (node2.operator === "&&") {
+          const left = evalNode(node2.left);
+          assertBoolean(left, "Operator '&&'", "left");
+          if (!left)
+            return false;
+          const right = evalNode(node2.right);
+          assertBoolean(right, "Operator '&&'", "right");
+          return right;
+        }
+        if (node2.operator === "||") {
+          const left = evalNode(node2.left);
+          assertBoolean(left, "Operator '||'", "left");
+          if (left)
+            return true;
+          const right = evalNode(node2.right);
+          assertBoolean(right, "Operator '||'", "right");
+          return right;
+        }
+        return evaluateBinaryOperation(node2.operator, evalNode(node2.left), evalNode(node2.right));
       }
-      if (typeof fn !== "function") {
-        throw new Error(`${n.name} is not a function`);
+      case 4 /* UnaryOp */: {
+        const arg = evalNode(node2.argument);
+        if (node2.operator === "-") {
+          assertNumber(arg, "Operator '-' (unary)");
+          return -arg;
+        }
+        if (node2.operator === "!") {
+          assertBoolean(arg, "Operator '!'");
+          return !arg;
+        }
+        throw new Error(`Unknown unary operator: ${String(node2.operator)}`);
       }
-      const evaluatedArgs = n.args.map(recurse);
-      return fn(...evaluatedArgs);
-    },
-    Assignment: (n, recurse) => {
-      const value = recurse(n.value);
-      if (externalVariables.has(n.name)) {
-        const externalValue = variables.get(n.name);
-        if (externalValue !== undefined) {
-          return externalValue;
+      case 5 /* FunctionCall */: {
+        const fn = context.functions?.[node2.name];
+        if (fn === undefined) {
+          throw new Error(`Undefined function: ${node2.name}`);
+        }
+        if (typeof fn !== "function") {
+          throw new Error(`${node2.name} is not a function`);
         }
+        const nodeArgs = node2.args;
+        const evaluatedArgs = [];
+        for (let i = 0;i < nodeArgs.length; i++) {
+          evaluatedArgs.push(evalNode(nodeArgs[i]));
+        }
+        return fn(...evaluatedArgs);
       }
-      variables.set(n.name, value);
-      return value;
-    },
-    IfExpression: (n, recurse) => {
-      const condition = recurse(n.condition);
-      assertBoolean(condition, "If condition");
-      return condition ? recurse(n.consequent) : recurse(n.alternate);
-    },
-    IndexAccess: (n, recurse) => {
-      const object = recurse(n.object);
-      const index = recurse(n.index);
-      if (Array.isArray(object)) {
-        return resolveIndex(object, index);
+      case 6 /* Assignment */: {
+        const value2 = evalNode(node2.value);
+        if (externalVariables.has(node2.name)) {
+          const externalValue = variables.get(node2.name);
+          if (externalValue !== undefined) {
+            return externalValue;
+          }
+        }
+        variables.set(node2.name, value2);
+        return value2;
       }
-      if (typeof object === "string") {
-        return resolveIndex(object, index);
+      case 7 /* IfExpression */: {
+        const condition = evalNode(node2.condition);
+        assertBoolean(condition, "If condition");
+        return condition ? evalNode(node2.consequent) : evalNode(node2.alternate);
       }
-      throw new TypeError(`Index access expected array or string, got ${typeOf(object)}`);
-    },
-    RangeExpression: (n, recurse) => {
-      const start = recurse(n.start);
-      const end = recurse(n.end);
-      assertNumber(start, "Range start");
-      assertNumber(end, "Range end");
-      return buildRange(start, end, n.inclusive);
-    },
-    PipeExpression: (n, recurse) => {
-      const pipedValue = recurse(n.value);
-      const fn = context.functions?.[n.name];
-      if (fn === undefined) {
-        throw new Error(`Undefined function: ${n.name}`);
+      case 12 /* IndexAccess */: {
+        const object = evalNode(node2.object);
+        const index = evalNode(node2.index);
+        if (Array.isArray(object)) {
+          return resolveIndex(object, index);
+        }
+        if (typeof object === "string") {
+          return resolveIndex(object, index);
+        }
+        throw new TypeError(`Index access expected array or string, got ${typeOf(object)}`);
       }
-      if (typeof fn !== "function") {
-        throw new Error(`${n.name} is not a function`);
+      case 13 /* RangeExpression */: {
+        const start = evalNode(node2.start);
+        const end = evalNode(node2.end);
+        assertNumber(start, "Range start");
+        assertNumber(end, "Range end");
+        return buildRange(start, end, node2.inclusive);
       }
-      const evaluatedArgs = n.args.map((arg) => arg.kind === 15 /* Placeholder */ ? pipedValue : recurse(arg));
-      return fn(...evaluatedArgs);
-    },
-    Placeholder: () => {
-      throw new Error("Placeholder outside pipe expression");
-    },
-    ForExpression: (n, recurse) => {
-      const iterable = recurse(n.iterable);
-      let items;
-      if (Array.isArray(iterable)) {
-        items = iterable;
-      } else if (typeof iterable === "string") {
-        items = Array.from(iterable);
-      } else {
-        throw new TypeError(`For expression expected array or string, got ${typeOf(iterable)}`);
+      case 14 /* PipeExpression */: {
+        const pipedValue = evalNode(node2.value);
+        const fn = context.functions?.[node2.name];
+        if (fn === undefined) {
+          throw new Error(`Undefined function: ${node2.name}`);
+        }
+        if (typeof fn !== "function") {
+          throw new Error(`${node2.name} is not a function`);
+        }
+        const pipeArgs = node2.args;
+        const evaluatedArgs = [];
+        for (let i = 0;i < pipeArgs.length; i++) {
+          const arg = pipeArgs[i];
+          evaluatedArgs.push(arg.kind === 15 /* Placeholder */ ? pipedValue : evalNode(arg));
+        }
+        return fn(...evaluatedArgs);
       }
-      const previousValue = variables.get(n.variable);
-      const hadPreviousValue = variables.has(n.variable);
-      const restoreLoopVar = () => {
-        if (hadPreviousValue) {
-          variables.set(n.variable, previousValue);
+      case 15 /* Placeholder */:
+        throw new Error("Placeholder outside pipe expression");
+      case 11 /* ForExpression */: {
+        const iterable = evalNode(node2.iterable);
+        let iterTarget;
+        if (Array.isArray(iterable)) {
+          iterTarget = iterable;
+        } else if (typeof iterable === "string") {
+          iterTarget = iterable;
         } else {
-          variables.delete(n.variable);
+          throw new TypeError(`For expression expected array or string, got ${typeOf(iterable)}`);
         }
-      };
-      if (n.accumulator) {
-        let acc = recurse(n.accumulator.initial);
-        const prevAcc = variables.get(n.accumulator.name);
-        const hadPrevAcc = variables.has(n.accumulator.name);
-        for (const item of items) {
-          variables.set(n.variable, item);
-          if (n.guard) {
-            const guardValue = recurse(n.guard);
+        const previousValue = variables.get(node2.variable);
+        const hadPreviousValue = variables.has(node2.variable);
+        if (node2.accumulator) {
+          let acc = evalNode(node2.accumulator.initial);
+          const prevAcc = variables.get(node2.accumulator.name);
+          const hadPrevAcc = variables.has(node2.accumulator.name);
+          for (const item of iterTarget) {
+            variables.set(node2.variable, item);
+            if (node2.guard) {
+              const guardValue = evalNode(node2.guard);
+              assertBoolean(guardValue, "For guard");
+              if (!guardValue)
+                continue;
+            }
+            variables.set(node2.accumulator.name, acc);
+            acc = evalNode(node2.body);
+          }
+          if (hadPrevAcc) {
+            variables.set(node2.accumulator.name, prevAcc);
+          } else {
+            variables.delete(node2.accumulator.name);
+          }
+          if (hadPreviousValue) {
+            variables.set(node2.variable, previousValue);
+          } else {
+            variables.delete(node2.variable);
+          }
+          return acc;
+        }
+        const result = [];
+        for (const item of iterTarget) {
+          variables.set(node2.variable, item);
+          if (node2.guard) {
+            const guardValue = evalNode(node2.guard);
             assertBoolean(guardValue, "For guard");
             if (!guardValue)
               continue;
           }
-          variables.set(n.accumulator.name, acc);
-          acc = recurse(n.body);
+          result.push(evalNode(node2.body));
         }
-        if (hadPrevAcc) {
-          variables.set(n.accumulator.name, prevAcc);
+        if (hadPreviousValue) {
+          variables.set(node2.variable, previousValue);
         } else {
-          variables.delete(n.accumulator.name);
-        }
-        restoreLoopVar();
-        return acc;
-      }
-      const result = [];
-      for (const item of items) {
-        variables.set(n.variable, item);
-        if (n.guard) {
-          const guardValue = recurse(n.guard);
-          assertBoolean(guardValue, "For guard");
-          if (!guardValue)
-            continue;
+          variables.delete(node2.variable);
         }
-        result.push(recurse(n.body));
+        validateHomogeneousArray(result);
+        return result;
       }
-      restoreLoopVar();
-      validateHomogeneousArray(result);
-      return result;
     }
-  });
-}
-function run(input, context = {}) {
-  const node = typeof input === "string" ? parse(input) : input;
-  const entries = Object.entries(context.variables || {});
-  const variables = new Map(entries);
-  const externalVariables = new Set(entries.map(([key]) => key));
-  const value = evaluateNode(node, context, variables, externalVariables);
-  return { value, variables };
+  }
 }
 function evaluate(input, context = {}) {
   return run(input, context).value;
 }
 function evaluateScope(input, context = {}) {
-  const { variables } = run(input, context);
-  return Object.fromEntries(variables);
+  return evaluateWithScope(input, context).scope;
+}
+function evaluateWithScope(input, context = {}) {
+  const { value, variables } = run(input, context);
+  return {
+    value,
+    scope: Object.fromEntries(variables)
+  };
 }
 // src/optimizer.ts
 function preserveComments(original, replacement) {
@@ -1843,24 +1954,34 @@ function isLiteral(node) {
   return isNumberLiteral(node) || isStringLiteral(node) || isBooleanLiteral(node);
 }
 function mightHaveSideEffects(node) {
-  return visit(node, {
-    Program: (n, recurse) => n.statements.some(recurse),
-    NumberLiteral: () => false,
-    StringLiteral: () => false,
-    BooleanLiteral: () => false,
-    Identifier: () => false,
-    ArrayLiteral: (n, recurse) => n.elements.some(recurse),
-    BinaryOp: (n, recurse) => recurse(n.left) || recurse(n.right),
-    UnaryOp: (n, recurse) => recurse(n.argument),
-    FunctionCall: () => true,
-    PipeExpression: () => true,
-    Placeholder: () => false,
-    Assignment: () => true,
-    IfExpression: (n, recurse) => recurse(n.condition) || recurse(n.consequent) || recurse(n.alternate),
-    ForExpression: (n, recurse) => recurse(n.iterable) || (n.guard ? recurse(n.guard) : false) || (n.accumulator ? recurse(n.accumulator.initial) : false) || recurse(n.body),
-    IndexAccess: (n, recurse) => recurse(n.object) || recurse(n.index),
-    RangeExpression: (n, recurse) => recurse(n.start) || recurse(n.end)
-  });
+  switch (node.kind) {
+    case 0 /* Program */:
+      return node.statements.some(mightHaveSideEffects);
+    case 10 /* ArrayLiteral */:
+      return node.elements.some(mightHaveSideEffects);
+    case 3 /* BinaryOp */:
+      return mightHaveSideEffects(node.left) || mightHaveSideEffects(node.right);
+    case 4 /* UnaryOp */:
+      return mightHaveSideEffects(node.argument);
+    case 7 /* IfExpression */:
+      return mightHaveSideEffects(node.condition) || mightHaveSideEffects(node.consequent) || mightHaveSideEffects(node.alternate);
+    case 11 /* ForExpression */:
+      return mightHaveSideEffects(node.iterable) || node.guard !== null && mightHaveSideEffects(node.guard) || node.accumulator !== null && mightHaveSideEffects(node.accumulator.initial) || mightHaveSideEffects(node.body);
+    case 12 /* IndexAccess */:
+      return mightHaveSideEffects(node.object) || mightHaveSideEffects(node.index);
+    case 13 /* RangeExpression */:
+      return mightHaveSideEffects(node.start) || mightHaveSideEffects(node.end);
+    case 5 /* FunctionCall */:
+    case 14 /* PipeExpression */:
+    case 6 /* Assignment */:
+      return true;
+    case 1 /* NumberLiteral */:
+    case 8 /* StringLiteral */:
+    case 9 /* BooleanLiteral */:
+    case 2 /* Identifier */:
+    case 15 /* Placeholder */:
+      return false;
+  }
 }
 function propagateConstants(program2, externalVariables) {
   const statements = program2.statements;
@@ -1891,10 +2012,9 @@ function propagateConstants(program2, externalVariables) {
     return null;
   const referencedIds = new Set;
   for (const stmt of statements) {
-    if (isAssignment(stmt)) {
-      collectReferencedIdentifiers(stmt.value, referencedIds);
-    } else {
-      collectReferencedIdentifiers(stmt, referencedIds);
+    const identifiers = collectAllIdentifiers(isAssignment(stmt) ? stmt.value : stmt);
+    for (const id of identifiers) {
+      referencedIds.add(id);
     }
   }
   let hasSubstitution = false;
@@ -1912,221 +2032,230 @@ function propagateConstants(program2, externalVariables) {
   }
   return result;
 }
-function collectReferencedIdentifiers(node, ids) {
-  visit(node, {
-    Program: (n, recurse) => {
-      for (const s of n.statements)
-        recurse(s);
-    },
-    NumberLiteral: () => {},
-    StringLiteral: () => {},
-    BooleanLiteral: () => {},
-    ArrayLiteral: (n, recurse) => {
-      for (const e of n.elements)
-        recurse(e);
-    },
-    Identifier: (n) => {
-      ids.add(n.name);
-    },
-    BinaryOp: (n, recurse) => {
-      recurse(n.left);
-      recurse(n.right);
-    },
-    UnaryOp: (n, recurse) => {
-      recurse(n.argument);
-    },
-    FunctionCall: (n, recurse) => {
-      for (const a of n.args)
-        recurse(a);
-    },
-    Assignment: (n, recurse) => {
-      recurse(n.value);
-    },
-    IfExpression: (n, recurse) => {
-      recurse(n.condition);
-      recurse(n.consequent);
-      recurse(n.alternate);
-    },
-    ForExpression: (n, recurse) => {
-      recurse(n.iterable);
-      if (n.guard)
-        recurse(n.guard);
-      if (n.accumulator)
-        recurse(n.accumulator.initial);
-      recurse(n.body);
-    },
-    IndexAccess: (n, recurse) => {
-      recurse(n.object);
-      recurse(n.index);
-    },
-    RangeExpression: (n, recurse) => {
-      recurse(n.start);
-      recurse(n.end);
-    },
-    PipeExpression: (n, recurse) => {
-      recurse(n.value);
-      for (const a of n.args)
-        recurse(a);
-    },
-    Placeholder: () => {}
-  });
-}
 function collectForLoopVars(node, vars) {
-  visit(node, {
-    Program: (n, recurse) => {
-      for (const s of n.statements)
-        recurse(s);
-    },
-    NumberLiteral: () => {},
-    StringLiteral: () => {},
-    BooleanLiteral: () => {},
-    ArrayLiteral: (n, recurse) => {
-      for (const e of n.elements)
-        recurse(e);
-    },
-    Identifier: () => {},
-    BinaryOp: (n, recurse) => {
-      recurse(n.left);
-      recurse(n.right);
-    },
-    UnaryOp: (n, recurse) => {
-      recurse(n.argument);
-    },
-    FunctionCall: (n, recurse) => {
-      for (const a of n.args)
-        recurse(a);
-    },
-    Assignment: (n, recurse) => {
-      recurse(n.value);
-    },
-    IfExpression: (n, recurse) => {
-      recurse(n.condition);
-      recurse(n.consequent);
-      recurse(n.alternate);
-    },
-    ForExpression: (n, recurse) => {
-      vars.add(n.variable);
-      if (n.accumulator)
-        vars.add(n.accumulator.name);
-      recurse(n.iterable);
-      if (n.guard)
-        recurse(n.guard);
-      if (n.accumulator)
-        recurse(n.accumulator.initial);
-      recurse(n.body);
-    },
-    IndexAccess: (n, recurse) => {
-      recurse(n.object);
-      recurse(n.index);
-    },
-    RangeExpression: (n, recurse) => {
-      recurse(n.start);
-      recurse(n.end);
-    },
-    PipeExpression: (n, recurse) => {
-      recurse(n.value);
-      for (const a of n.args)
-        recurse(a);
-    },
-    Placeholder: () => {}
-  });
+  switch (node.kind) {
+    case 0 /* Program */:
+      for (const s of node.statements)
+        collectForLoopVars(s, vars);
+      break;
+    case 10 /* ArrayLiteral */:
+      for (const e of node.elements)
+        collectForLoopVars(e, vars);
+      break;
+    case 3 /* BinaryOp */:
+      collectForLoopVars(node.left, vars);
+      collectForLoopVars(node.right, vars);
+      break;
+    case 4 /* UnaryOp */:
+      collectForLoopVars(node.argument, vars);
+      break;
+    case 5 /* FunctionCall */:
+      for (const a of node.args)
+        collectForLoopVars(a, vars);
+      break;
+    case 6 /* Assignment */:
+      collectForLoopVars(node.value, vars);
+      break;
+    case 7 /* IfExpression */:
+      collectForLoopVars(node.condition, vars);
+      collectForLoopVars(node.consequent, vars);
+      collectForLoopVars(node.alternate, vars);
+      break;
+    case 11 /* ForExpression */:
+      vars.add(node.variable);
+      if (node.accumulator)
+        vars.add(node.accumulator.name);
+      collectForLoopVars(node.iterable, vars);
+      if (node.guard)
+        collectForLoopVars(node.guard, vars);
+      if (node.accumulator)
+        collectForLoopVars(node.accumulator.initial, vars);
+      collectForLoopVars(node.body, vars);
+      break;
+    case 12 /* IndexAccess */:
+      collectForLoopVars(node.object, vars);
+      collectForLoopVars(node.index, vars);
+      break;
+    case 13 /* RangeExpression */:
+      collectForLoopVars(node.start, vars);
+      collectForLoopVars(node.end, vars);
+      break;
+    case 14 /* PipeExpression */:
+      collectForLoopVars(node.value, vars);
+      for (const a of node.args)
+        collectForLoopVars(a, vars);
+      break;
+    case 1 /* NumberLiteral */:
+    case 8 /* StringLiteral */:
+    case 9 /* BooleanLiteral */:
+    case 2 /* Identifier */:
+    case 15 /* Placeholder */:
+      break;
+  }
 }
 function countAssignments(node, counts) {
-  visit(node, {
-    Program: (n, recurse) => {
-      for (const s of n.statements)
-        recurse(s);
-    },
-    NumberLiteral: () => {},
-    StringLiteral: () => {},
-    BooleanLiteral: () => {},
-    ArrayLiteral: (n, recurse) => {
-      for (const e of n.elements)
-        recurse(e);
-    },
-    Identifier: () => {},
-    BinaryOp: (n, recurse) => {
-      recurse(n.left);
-      recurse(n.right);
-    },
-    UnaryOp: (n, recurse) => {
-      recurse(n.argument);
-    },
-    FunctionCall: (n, recurse) => {
-      for (const a of n.args)
-        recurse(a);
-    },
-    Assignment: (n, recurse) => {
-      counts.set(n.name, (counts.get(n.name) ?? 0) + 1);
-      recurse(n.value);
-    },
-    IfExpression: (n, recurse) => {
-      recurse(n.condition);
-      recurse(n.consequent);
-      recurse(n.alternate);
-    },
-    ForExpression: (n, recurse) => {
-      recurse(n.iterable);
-      if (n.guard)
-        recurse(n.guard);
-      if (n.accumulator)
-        recurse(n.accumulator.initial);
-      recurse(n.body);
-    },
-    IndexAccess: (n, recurse) => {
-      recurse(n.object);
-      recurse(n.index);
-    },
-    RangeExpression: (n, recurse) => {
-      recurse(n.start);
-      recurse(n.end);
-    },
-    PipeExpression: (n, recurse) => {
-      recurse(n.value);
-      for (const a of n.args)
-        recurse(a);
-    },
-    Placeholder: () => {}
-  });
+  switch (node.kind) {
+    case 0 /* Program */:
+      for (const s of node.statements)
+        countAssignments(s, counts);
+      break;
+    case 6 /* Assignment */:
+      counts.set(node.name, (counts.get(node.name) ?? 0) + 1);
+      countAssignments(node.value, counts);
+      break;
+    case 10 /* ArrayLiteral */:
+      for (const e of node.elements)
+        countAssignments(e, counts);
+      break;
+    case 3 /* BinaryOp */:
+      countAssignments(node.left, counts);
+      countAssignments(node.right, counts);
+      break;
+    case 4 /* UnaryOp */:
+      countAssignments(node.argument, counts);
+      break;
+    case 5 /* FunctionCall */:
+      for (const a of node.args)
+        countAssignments(a, counts);
+      break;
+    case 7 /* IfExpression */:
+      countAssignments(node.condition, counts);
+      countAssignments(node.consequent, counts);
+      countAssignments(node.alternate, counts);
+      break;
+    case 11 /* ForExpression */:
+      countAssignments(node.iterable, counts);
+      if (node.guard)
+        countAssignments(node.guard, counts);
+      if (node.accumulator)
+        countAssignments(node.accumulator.initial, counts);
+      countAssignments(node.body, counts);
+      break;
+    case 12 /* IndexAccess */:
+      countAssignments(node.object, counts);
+      countAssignments(node.index, counts);
+      break;
+    case 13 /* RangeExpression */:
+      countAssignments(node.start, counts);
+      countAssignments(node.end, counts);
+      break;
+    case 14 /* PipeExpression */:
+      countAssignments(node.value, counts);
+      for (const a of node.args)
+        countAssignments(a, counts);
+      break;
+    case 1 /* NumberLiteral */:
+    case 8 /* StringLiteral */:
+    case 9 /* BooleanLiteral */:
+    case 2 /* Identifier */:
+    case 15 /* Placeholder */:
+      break;
+  }
+}
+function unchangedArray(original, mapped) {
+  for (let i = 0;i < original.length; i++) {
+    if (original[i] !== mapped[i])
+      return false;
+  }
+  return true;
 }
 function substituteIdentifiers(node, knownValues) {
-  return visit(node, {
-    Program: (n, recurse) => {
-      const result = program(n.statements.map(recurse));
-      if (n.trailingComments && n.trailingComments.length > 0) {
-        return { ...result, trailingComments: n.trailingComments };
+  const recurse = (n) => substituteIdentifiers(n, knownValues);
+  switch (node.kind) {
+    case 0 /* Program */: {
+      const stmts = node.statements.map(recurse);
+      if (unchangedArray(node.statements, stmts))
+        return node;
+      const result = program(stmts);
+      if (node.trailingComments && node.trailingComments.length > 0) {
+        return { ...result, trailingComments: node.trailingComments };
       }
       return result;
-    },
-    NumberLiteral: (n) => n,
-    StringLiteral: (n) => n,
-    BooleanLiteral: (n) => n,
-    ArrayLiteral: (n, recurse) => preserveComments(n, array(n.elements.map(recurse))),
-    Identifier: (n) => {
-      const replacement = knownValues.get(n.name);
-      return replacement ? preserveComments(n, replacement) : n;
-    },
-    BinaryOp: (n, recurse) => preserveComments(n, binaryOp(recurse(n.left), n.operator, recurse(n.right))),
-    UnaryOp: (n, recurse) => preserveComments(n, unaryOp(n.operator, recurse(n.argument))),
-    FunctionCall: (n, recurse) => preserveComments(n, functionCall(n.name, n.args.map(recurse))),
-    Assignment: (n, recurse) => preserveComments(n, assign(n.name, recurse(n.value))),
-    IfExpression: (n, recurse) => preserveComments(n, ifExpr(recurse(n.condition), recurse(n.consequent), recurse(n.alternate))),
-    ForExpression: (n, recurse) => {
+    }
+    case 1 /* NumberLiteral */:
+    case 8 /* StringLiteral */:
+    case 9 /* BooleanLiteral */:
+    case 15 /* Placeholder */:
+      return node;
+    case 10 /* ArrayLiteral */: {
+      const elements = node.elements.map(recurse);
+      if (unchangedArray(node.elements, elements))
+        return node;
+      return preserveComments(node, array(elements));
+    }
+    case 2 /* Identifier */: {
+      const replacement = knownValues.get(node.name);
+      return replacement ? preserveComments(node, replacement) : node;
+    }
+    case 3 /* BinaryOp */: {
+      const left = recurse(node.left);
+      const right = recurse(node.right);
+      if (left === node.left && right === node.right)
+        return node;
+      return preserveComments(node, binaryOp(left, node.operator, right));
+    }
+    case 4 /* UnaryOp */: {
+      const argument = recurse(node.argument);
+      if (argument === node.argument)
+        return node;
+      return preserveComments(node, unaryOp(node.operator, argument));
+    }
+    case 5 /* FunctionCall */: {
+      const args = node.args.map(recurse);
+      if (unchangedArray(node.args, args))
+        return node;
+      return preserveComments(node, functionCall(node.name, args));
+    }
+    case 6 /* Assignment */: {
+      const value = recurse(node.value);
+      if (value === node.value)
+        return node;
+      return preserveComments(node, assign(node.name, value));
+    }
+    case 7 /* IfExpression */: {
+      const condition = recurse(node.condition);
+      const consequent = recurse(node.consequent);
+      const alternate = recurse(node.alternate);
+      if (condition === node.condition && consequent === node.consequent && alternate === node.alternate)
+        return node;
+      return preserveComments(node, ifExpr(condition, consequent, alternate));
+    }
+    case 11 /* ForExpression */: {
       const innerKnown = new Map(knownValues);
-      innerKnown.delete(n.variable);
-      if (n.accumulator)
-        innerKnown.delete(n.accumulator.name);
-      const iterable = recurse(n.iterable);
-      const guard = n.guard ? substituteIdentifiers(n.guard, innerKnown) : null;
-      const accumulator = n.accumulator ? { name: n.accumulator.name, initial: recurse(n.accumulator.initial) } : null;
-      const body = substituteIdentifiers(n.body, innerKnown);
-      return preserveComments(n, forExpr(n.variable, iterable, guard, accumulator, body));
-    },
-    IndexAccess: (n, recurse) => preserveComments(n, indexAccess(recurse(n.object), recurse(n.index))),
-    RangeExpression: (n, recurse) => preserveComments(n, rangeExpr(recurse(n.start), recurse(n.end), n.inclusive)),
-    PipeExpression: (n, recurse) => preserveComments(n, pipeExpr(recurse(n.value), n.name, n.args.map(recurse))),
-    Placeholder: (n) => n
-  });
+      innerKnown.delete(node.variable);
+      if (node.accumulator)
+        innerKnown.delete(node.accumulator.name);
+      const iterable = recurse(node.iterable);
+      const guard = node.guard ? substituteIdentifiers(node.guard, innerKnown) : null;
+      const initial = node.accumulator ? recurse(node.accumulator.initial) : null;
+      const body = substituteIdentifiers(node.body, innerKnown);
+      if (iterable === node.iterable && guard === node.guard && (node.accumulator === null || initial === node.accumulator.initial) && body === node.body)
+        return node;
+      const accumulator = node.accumulator ? { name: node.accumulator.name, initial } : null;
+      return preserveComments(node, forExpr(node.variable, iterable, guard, accumulator, body));
+    }
+    case 12 /* IndexAccess */: {
+      const object = recurse(node.object);
+      const index = recurse(node.index);
+      if (object === node.object && index === node.index)
+        return node;
+      return preserveComments(node, indexAccess(object, index));
+    }
+    case 13 /* RangeExpression */: {
+      const start = recurse(node.start);
+      const end = recurse(node.end);
+      if (start === node.start && end === node.end)
+        return node;
+      return preserveComments(node, rangeExpr(start, end, node.inclusive));
+    }
+    case 14 /* PipeExpression */: {
+      const value = recurse(node.value);
+      const args = node.args.map(recurse);
+      if (value === node.value && unchangedArray(node.args, args))
+        return node;
+      return preserveComments(node, pipeExpr(value, node.name, args));
+    }
+  }
 }
 function optimize(node, externalVariables) {
   let propagated = fold(node);
@@ -2153,142 +2282,168 @@ function optimize(node, externalVariables) {
   return propagated;
 }
 function fold(node) {
-  return visit(node, {
-    NumberLiteral: (n) => n,
-    StringLiteral: (n) => n,
-    BooleanLiteral: (n) => n,
-    ArrayLiteral: (n, recurse) => {
-      const elements = n.elements.map(recurse);
-      return preserveComments(n, array(elements));
-    },
-    Identifier: (n) => n,
-    BinaryOp: (n, recurse) => {
-      const left = recurse(n.left);
-      const right = recurse(n.right);
+  const recurse = fold;
+  switch (node.kind) {
+    case 1 /* NumberLiteral */:
+    case 8 /* StringLiteral */:
+    case 9 /* BooleanLiteral */:
+    case 2 /* Identifier */:
+    case 15 /* Placeholder */:
+      return node;
+    case 0 /* Program */: {
+      const optimizedStatements = node.statements.map(recurse);
+      if (unchangedArray(node.statements, optimizedStatements))
+        return node;
+      const result = program(optimizedStatements);
+      if (node.trailingComments && node.trailingComments.length > 0) {
+        return { ...result, trailingComments: node.trailingComments };
+      }
+      return result;
+    }
+    case 10 /* ArrayLiteral */: {
+      const elements = node.elements.map(recurse);
+      if (unchangedArray(node.elements, elements))
+        return node;
+      return preserveComments(node, array(elements));
+    }
+    case 3 /* BinaryOp */: {
+      const left = recurse(node.left);
+      const right = recurse(node.right);
       if (isNumberLiteral(left) && isNumberLiteral(right)) {
-        const result = evaluateBinaryOperation(n.operator, left.value, right.value);
+        const result = evaluateBinaryOperation(node.operator, left.value, right.value);
         if (typeof result === "number")
-          return preserveComments(n, number(result));
+          return preserveComments(node, number(result));
         if (typeof result === "boolean")
-          return preserveComments(n, boolean(result));
+          return preserveComments(node, boolean(result));
       }
       if (isStringLiteral(left) && isStringLiteral(right)) {
-        if (n.operator === "+")
-          return preserveComments(n, string(left.value + right.value));
-        if (n.operator === "<" || n.operator === ">" || n.operator === "<=" || n.operator === ">=") {
-          const result = evaluateBinaryOperation(n.operator, left.value, right.value);
-          return preserveComments(n, boolean(result));
+        if (node.operator === "+")
+          return preserveComments(node, string(left.value + right.value));
+        if (node.operator === "<" || node.operator === ">" || node.operator === "<=" || node.operator === ">=") {
+          const result = evaluateBinaryOperation(node.operator, left.value, right.value);
+          return preserveComments(node, boolean(result));
         }
-        if (n.operator === "==")
-          return preserveComments(n, boolean(left.value === right.value));
-        if (n.operator === "!=")
-          return preserveComments(n, boolean(left.value !== right.value));
+        if (node.operator === "==")
+          return preserveComments(node, boolean(left.value === right.value));
+        if (node.operator === "!=")
+          return preserveComments(node, boolean(left.value !== right.value));
       }
       if (isBooleanLiteral(left) && isBooleanLiteral(right)) {
-        if (n.operator === "&&")
-          return preserveComments(n, boolean(left.value && right.value));
-        if (n.operator === "||")
-          return preserveComments(n, boolean(left.value || right.value));
-        if (n.operator === "==")
-          return preserveComments(n, boolean(left.value === right.value));
-        if (n.operator === "!=")
-          return preserveComments(n, boolean(left.value !== right.value));
+        if (node.operator === "&&")
+          return preserveComments(node, boolean(left.value && right.value));
+        if (node.operator === "||")
+          return preserveComments(node, boolean(left.value || right.value));
+        if (node.operator === "==")
+          return preserveComments(node, boolean(left.value === right.value));
+        if (node.operator === "!=")
+          return preserveComments(node, boolean(left.value !== right.value));
       }
       if (isLiteral(left) && isLiteral(right)) {
         if (left.kind !== right.kind) {
-          if (n.operator === "==")
-            return preserveComments(n, boolean(false));
-          if (n.operator === "!=")
-            return preserveComments(n, boolean(true));
+          if (node.operator === "==")
+            return preserveComments(node, boolean(false));
+          if (node.operator === "!=")
+            return preserveComments(node, boolean(true));
         }
       }
-      return preserveComments(n, binaryOp(left, n.operator, right));
-    },
-    UnaryOp: (n, recurse) => {
-      const argument = recurse(n.argument);
-      if (n.operator === "-" && isNumberLiteral(argument)) {
-        return preserveComments(n, number(-argument.value));
+      if (left === node.left && right === node.right)
+        return node;
+      return preserveComments(node, binaryOp(left, node.operator, right));
+    }
+    case 4 /* UnaryOp */: {
+      const argument = recurse(node.argument);
+      if (node.operator === "-" && isNumberLiteral(argument)) {
+        return preserveComments(node, number(-argument.value));
       }
-      if (n.operator === "!" && isBooleanLiteral(argument)) {
-        return preserveComments(n, boolean(!argument.value));
+      if (node.operator === "!" && isBooleanLiteral(argument)) {
+        return preserveComments(node, boolean(!argument.value));
       }
-      return preserveComments(n, unaryOp(n.operator, argument));
-    },
-    FunctionCall: (n, recurse) => {
-      const optimizedArgs = n.args.map(recurse);
-      return preserveComments(n, functionCall(n.name, optimizedArgs));
-    },
-    Assignment: (n, recurse) => {
-      return preserveComments(n, assign(n.name, recurse(n.value)));
-    },
-    IfExpression: (n, recurse) => {
-      const condition = recurse(n.condition);
+      if (argument === node.argument)
+        return node;
+      return preserveComments(node, unaryOp(node.operator, argument));
+    }
+    case 5 /* FunctionCall */: {
+      const optimizedArgs = node.args.map(recurse);
+      if (unchangedArray(node.args, optimizedArgs))
+        return node;
+      return preserveComments(node, functionCall(node.name, optimizedArgs));
+    }
+    case 6 /* Assignment */: {
+      const value = recurse(node.value);
+      if (value === node.value)
+        return node;
+      return preserveComments(node, assign(node.name, value));
+    }
+    case 7 /* IfExpression */: {
+      const condition = recurse(node.condition);
       if (isBooleanLiteral(condition)) {
-        const result = condition.value ? recurse(n.consequent) : recurse(n.alternate);
-        return preserveComments(n, result);
+        const result = condition.value ? recurse(node.consequent) : recurse(node.alternate);
+        return preserveComments(node, result);
       }
-      const consequent = recurse(n.consequent);
-      const alternate = recurse(n.alternate);
-      return preserveComments(n, ifExpr(condition, consequent, alternate));
-    },
-    ForExpression: (n, recurse) => {
-      const iterable = recurse(n.iterable);
-      const guard = n.guard ? recurse(n.guard) : null;
-      const accumulator = n.accumulator ? { name: n.accumulator.name, initial: recurse(n.accumulator.initial) } : null;
-      const body = recurse(n.body);
-      return preserveComments(n, forExpr(n.variable, iterable, guard, accumulator, body));
-    },
-    IndexAccess: (n, recurse) => {
-      const object = recurse(n.object);
-      const index = recurse(n.index);
+      const consequent = recurse(node.consequent);
+      const alternate = recurse(node.alternate);
+      if (condition === node.condition && consequent === node.consequent && alternate === node.alternate)
+        return node;
+      return preserveComments(node, ifExpr(condition, consequent, alternate));
+    }
+    case 11 /* ForExpression */: {
+      const iterable = recurse(node.iterable);
+      const guard = node.guard ? recurse(node.guard) : null;
+      const initial = node.accumulator ? recurse(node.accumulator.initial) : null;
+      const body = recurse(node.body);
+      if (iterable === node.iterable && guard === node.guard && (node.accumulator === null || initial === node.accumulator.initial) && body === node.body)
+        return node;
+      const accumulator = node.accumulator ? { name: node.accumulator.name, initial } : null;
+      return preserveComments(node, forExpr(node.variable, iterable, guard, accumulator, body));
+    }
+    case 12 /* IndexAccess */: {
+      const object = recurse(node.object);
+      const index = recurse(node.index);
       if (isArrayLiteral(object) && isNumberLiteral(index)) {
         const idx = index.value;
         if (Number.isInteger(idx)) {
           const len = object.elements.length;
           const resolved = idx < 0 ? len + idx : idx;
           if (resolved >= 0 && resolved < len) {
-            return preserveComments(n, object.elements[resolved]);
+            return preserveComments(node, object.elements[resolved]);
           }
         }
       }
       if (isStringLiteral(object) && isNumberLiteral(index)) {
         try {
           const char = resolveIndex(object.value, index.value);
-          return preserveComments(n, string(char));
+          return preserveComments(node, string(char));
         } catch {}
       }
-      return preserveComments(n, indexAccess(object, index));
-    },
-    RangeExpression: (n, recurse) => {
-      const start = recurse(n.start);
-      const end = recurse(n.end);
+      if (object === node.object && index === node.index)
+        return node;
+      return preserveComments(node, indexAccess(object, index));
+    }
+    case 13 /* RangeExpression */: {
+      const start = recurse(node.start);
+      const end = recurse(node.end);
       if (isNumberLiteral(start) && isNumberLiteral(end)) {
         try {
-          const limit = n.inclusive ? end.value + 1 : end.value;
+          const limit = node.inclusive ? end.value + 1 : end.value;
           const count = limit - start.value;
           if (count >= 0 && count <= 1e4) {
-            const values = buildRange(start.value, end.value, n.inclusive);
-            return preserveComments(n, array(values.map(number)));
+            const values = buildRange(start.value, end.value, node.inclusive);
+            return preserveComments(node, array(values.map(number)));
           }
         } catch {}
       }
-      return preserveComments(n, rangeExpr(start, end, n.inclusive));
-    },
-    PipeExpression: (n, recurse) => {
-      const value = recurse(n.value);
-      const optimizedArgs = n.args.map(recurse);
-      return preserveComments(n, pipeExpr(value, n.name, optimizedArgs));
-    },
-    Placeholder: (n) => n,
-    Program: (n, recurse) => {
-      const optimizedStatements = n.statements.map(recurse);
-      const result = program(optimizedStatements);
-      if (n.trailingComments && n.trailingComments.length > 0) {
-        return { ...result, trailingComments: n.trailingComments };
-      }
-      return result;
+      if (start === node.start && end === node.end)
+        return node;
+      return preserveComments(node, rangeExpr(start, end, node.inclusive));
     }
-  });
+    case 14 /* PipeExpression */: {
+      const value = recurse(node.value);
+      const optimizedArgs = node.args.map(recurse);
+      if (value === node.value && unchangedArray(node.args, optimizedArgs))
+        return node;
+      return preserveComments(node, pipeExpr(value, node.name, optimizedArgs));
+    }
+  }
 }
 // src/stdlib/array.ts
 var exports_array = {};
@@ -2296,52 +2451,11 @@ __export(exports_array, {
   ARR_UNIQUE: () => ARR_UNIQUE,
   ARR_SUM: () => ARR_SUM,
   ARR_SORT: () => ARR_SORT,
-  ARR_SLICE: () => ARR_SLICE,
-  ARR_REVERSE: () => ARR_REVERSE,
-  ARR_PUSH: () => ARR_PUSH,
   ARR_MIN: () => ARR_MIN,
   ARR_MAX: () => ARR_MAX,
-  ARR_LEN: () => ARR_LEN,
   ARR_JOIN: () => ARR_JOIN,
-  ARR_FLAT: () => ARR_FLAT,
-  ARR_CONTAINS: () => ARR_CONTAINS
+  ARR_FLAT: () => ARR_FLAT
 });
-var ARR_LEN = (a) => {
-  assertArray(a, "ARR_LEN");
-  return a.length;
-};
-var ARR_PUSH = (a, value) => {
-  assertArray(a, "ARR_PUSH");
-  if (a.length > 0) {
-    const elemType = typeOf(a[0]);
-    const valType = typeOf(value);
-    if (elemType !== valType) {
-      throw new TypeError(`ARR_PUSH: cannot push ${valType} into array<${elemType}>`);
-    }
-  }
-  return [...a, value];
-};
-var ARR_SLICE = (a, start, end) => {
-  assertArray(a, "ARR_SLICE");
-  assertNumber(start, "ARR_SLICE", "start");
-  if (end !== undefined) {
-    assertNumber(end, "ARR_SLICE", "end");
-    return a.slice(start, end);
-  }
-  return a.slice(start);
-};
-var ARR_CONTAINS = (a, value) => {
-  assertArray(a, "ARR_CONTAINS");
-  for (const elem of a) {
-    if (deepEquals(elem, value))
-      return true;
-  }
-  return false;
-};
-var ARR_REVERSE = (a) => {
-  assertArray(a, "ARR_REVERSE");
-  return [...a].reverse();
-};
 var ARR_SORT = (a) => {
   assertArray(a, "ARR_SORT");
   if (a.length <= 1)
@@ -2473,7 +2587,12 @@ var exports_core = {};
 __export(exports_core, {
   TYPE: () => TYPE,
   STR: () => STR,
-  NUM: () => NUM
+  SLICE: () => SLICE,
+  REVERSE: () => REVERSE,
+  NUM: () => NUM,
+  LEN: () => LEN,
+  INDEX_OF: () => INDEX_OF,
+  CONTAINS: () => CONTAINS
 });
 var STR = (v) => {
   if (typeof v === "string")
@@ -2504,31 +2623,81 @@ var NUM = (v) => {
 var TYPE = (v) => {
   return typeOf(v);
 };
+function assertStringOrArray(v, context) {
+  if (typeof v !== "string" && !Array.isArray(v)) {
+    throw new TypeError(`${context} expected string or array, got ${typeOf(v)}`);
+  }
+}
+var LEN = (v) => {
+  assertStringOrArray(v, "LEN");
+  return v.length;
+};
+var SLICE = (v, start, end) => {
+  assertStringOrArray(v, "SLICE");
+  assertNumber(start, "SLICE", "start");
+  if (end !== undefined) {
+    assertNumber(end, "SLICE", "end");
+    return v.slice(start, end);
+  }
+  return v.slice(start);
+};
+var CONTAINS = (v, search) => {
+  assertStringOrArray(v, "CONTAINS");
+  if (typeof v === "string") {
+    assertString(search, "CONTAINS (search)");
+    return v.includes(search);
+  }
+  for (const elem of v) {
+    if (deepEquals(elem, search))
+      return true;
+  }
+  return false;
+};
+var REVERSE = (v) => {
+  assertStringOrArray(v, "REVERSE");
+  if (typeof v === "string") {
+    return Array.from(v).reverse().join("");
+  }
+  return [...v].reverse();
+};
+var INDEX_OF = (v, search) => {
+  assertStringOrArray(v, "INDEX_OF");
+  if (typeof v === "string") {
+    assertString(search, "INDEX_OF (search)");
+    return v.indexOf(search);
+  }
+  for (let i = 0;i < v.length; i++) {
+    if (deepEquals(v[i], search))
+      return i;
+  }
+  return -1;
+};
 
 // src/stdlib/datetime.ts
 var exports_datetime = {};
 __export(exports_datetime, {
+  YEAR: () => YEAR,
+  WEEKDAY: () => WEEKDAY,
   TODAY: () => TODAY,
   START_OF_YEAR: () => START_OF_YEAR,
   START_OF_WEEK: () => START_OF_WEEK,
   START_OF_QUARTER: () => START_OF_QUARTER,
   START_OF_MONTH: () => START_OF_MONTH,
+  QUARTER: () => QUARTER,
+  MONTH: () => MONTH,
   IS_WEEKEND: () => IS_WEEKEND,
   IS_SAME_DAY: () => IS_SAME_DAY,
   IS_LEAP_YEAR: () => IS_LEAP_YEAR,
-  GET_YEAR: () => GET_YEAR,
-  GET_WEEKDAY: () => GET_WEEKDAY,
-  GET_QUARTER: () => GET_QUARTER,
-  GET_MONTH: () => GET_MONTH,
-  GET_DAY_OF_YEAR: () => GET_DAY_OF_YEAR,
-  GET_DAY: () => GET_DAY,
   END_OF_YEAR: () => END_OF_YEAR,
   END_OF_MONTH: () => END_OF_MONTH,
   DIFFERENCE_IN_YEARS: () => DIFFERENCE_IN_YEARS,
   DIFFERENCE_IN_WEEKS: () => DIFFERENCE_IN_WEEKS,
   DIFFERENCE_IN_MONTHS: () => DIFFERENCE_IN_MONTHS,
   DIFFERENCE_IN_DAYS: () => DIFFERENCE_IN_DAYS,
+  DAY_OF_YEAR: () => DAY_OF_YEAR,
+  DAY: () => DAY,
   DATE: () => DATE,
+  AGE: () => AGE,
   ADD_YEARS: () => ADD_YEARS,
   ADD_MONTHS: () => ADD_MONTHS,
   ADD_DAYS: () => ADD_DAYS
@@ -2540,28 +2709,28 @@ var DATE = (year, month, day) => {
   assertNumber(day, "DATE", "day");
   return new Temporal.PlainDate(year, month, day);
 };
-var GET_YEAR = (date) => {
-  assertDateOrDateTime(date, "GET_YEAR");
+var YEAR = (date) => {
+  assertDateOrDateTime(date, "YEAR");
   return date.year;
 };
-var GET_MONTH = (date) => {
-  assertDateOrDateTime(date, "GET_MONTH");
+var MONTH = (date) => {
+  assertDateOrDateTime(date, "MONTH");
   return date.month;
 };
-var GET_DAY = (date) => {
-  assertDateOrDateTime(date, "GET_DAY");
+var DAY = (date) => {
+  assertDateOrDateTime(date, "DAY");
   return date.day;
 };
-var GET_WEEKDAY = (date) => {
-  assertDateOrDateTime(date, "GET_WEEKDAY");
+var WEEKDAY = (date) => {
+  assertDateOrDateTime(date, "WEEKDAY");
   return date.dayOfWeek;
 };
-var GET_DAY_OF_YEAR = (date) => {
-  assertDateOrDateTime(date, "GET_DAY_OF_YEAR");
+var DAY_OF_YEAR = (date) => {
+  assertDateOrDateTime(date, "DAY_OF_YEAR");
   return date.dayOfYear;
 };
-var GET_QUARTER = (date) => {
-  assertDateOrDateTime(date, "GET_QUARTER");
+var QUARTER = (date) => {
+  assertDateOrDateTime(date, "QUARTER");
   return Math.ceil(date.month / 3);
 };
 var ADD_DAYS = (date, days) => {
@@ -2676,6 +2845,22 @@ var IS_LEAP_YEAR = (date) => {
   assertDateOrDateTime(date, "IS_LEAP_YEAR");
   return date.inLeapYear;
 };
+var AGE = (birthDate, ...rest) => {
+  assertDateOrDateTime(birthDate, "AGE");
+  const birth = birthDate instanceof Temporal.PlainDateTime ? birthDate.toPlainDate() : birthDate;
+  let reference;
+  if (rest.length > 0) {
+    const ref = rest[0];
+    assertDateOrDateTime(ref, "AGE");
+    reference = ref instanceof Temporal.PlainDateTime ? ref.toPlainDate() : ref;
+  } else {
+    reference = Temporal.Now.plainDateISO();
+  }
+  if (Temporal.PlainDate.compare(birth, reference) > 0) {
+    throw new RangeError("AGE requires birth date to be on or before reference date");
+  }
+  return birth.until(reference, { largestUnit: "year" }).years;
+};
 
 // src/stdlib/datetimefull.ts
 var exports_datetimefull = {};
@@ -2822,19 +3007,11 @@ __export(exports_string, {
   STR_TRIM: () => STR_TRIM,
   STR_STARTS_WITH: () => STR_STARTS_WITH,
   STR_SPLIT: () => STR_SPLIT,
-  STR_SLICE: () => STR_SLICE,
   STR_REPLACE: () => STR_REPLACE,
   STR_REPEAT: () => STR_REPEAT,
   STR_LOWER: () => STR_LOWER,
-  STR_LEN: () => STR_LEN,
-  STR_INDEX_OF: () => STR_INDEX_OF,
-  STR_ENDS_WITH: () => STR_ENDS_WITH,
-  STR_CONTAINS: () => STR_CONTAINS
+  STR_ENDS_WITH: () => STR_ENDS_WITH
 });
-var STR_LEN = (s) => {
-  assertString(s, "STR_LEN");
-  return s.length;
-};
 var STR_UPPER = (s) => {
   assertString(s, "STR_UPPER");
   return s.toUpperCase();
@@ -2847,25 +3024,6 @@ var STR_TRIM = (s) => {
   assertString(s, "STR_TRIM");
   return s.trim();
 };
-var STR_SLICE = (s, start, end) => {
-  assertString(s, "STR_SLICE");
-  assertNumber(start, "STR_SLICE", "start");
-  if (end !== undefined) {
-    assertNumber(end, "STR_SLICE", "end");
-    return s.slice(start, end);
-  }
-  return s.slice(start);
-};
-var STR_CONTAINS = (s, search) => {
-  assertString(s, "STR_CONTAINS");
-  assertString(search, "STR_CONTAINS");
-  return s.includes(search);
-};
-var STR_INDEX_OF = (s, search) => {
-  assertString(s, "STR_INDEX_OF");
-  assertString(search, "STR_INDEX_OF");
-  return s.indexOf(search);
-};
 var STR_SPLIT = (s, sep) => {
   assertString(s, "STR_SPLIT");
   assertString(sep, "STR_SPLIT (separator)");
@@ -2900,12 +3058,12 @@ var STR_REPEAT = (s, count) => {
 var exports_time = {};
 __export(exports_time, {
   TIME: () => TIME,
+  SECOND: () => SECOND,
   NOW_TIME: () => NOW_TIME,
+  MINUTE: () => MINUTE,
+  MILLISECOND: () => MILLISECOND,
   IS_SAME_TIME: () => IS_SAME_TIME,
-  GET_SECOND: () => GET_SECOND,
-  GET_MINUTE: () => GET_MINUTE,
-  GET_MILLISECOND: () => GET_MILLISECOND,
-  GET_HOUR: () => GET_HOUR,
+  HOUR: () => HOUR,
   DIFFERENCE_IN_SECONDS: () => DIFFERENCE_IN_SECONDS,
   DIFFERENCE_IN_MINUTES: () => DIFFERENCE_IN_MINUTES,
   DIFFERENCE_IN_HOURS: () => DIFFERENCE_IN_HOURS,
@@ -2920,20 +3078,20 @@ var TIME = (hour, minute, second) => {
   return new Temporal.PlainTime(hour, minute, second);
 };
 var NOW_TIME = () => Temporal.Now.plainTimeISO();
-var GET_HOUR = (t) => {
-  assertTimeOrDateTime(t, "GET_HOUR");
+var HOUR = (t) => {
+  assertTimeOrDateTime(t, "HOUR");
   return t.hour;
 };
-var GET_MINUTE = (t) => {
-  assertTimeOrDateTime(t, "GET_MINUTE");
+var MINUTE = (t) => {
+  assertTimeOrDateTime(t, "MINUTE");
   return t.minute;
 };
-var GET_SECOND = (t) => {
-  assertTimeOrDateTime(t, "GET_SECOND");
+var SECOND = (t) => {
+  assertTimeOrDateTime(t, "SECOND");
   return t.second;
 };
-var GET_MILLISECOND = (t) => {
-  assertTimeOrDateTime(t, "GET_MILLISECOND");
+var MILLISECOND = (t) => {
+  assertTimeOrDateTime(t, "MILLISECOND");
   return t.millisecond;
 };
 var ADD_HOURS = (t, hours) => {
@@ -3016,9 +3174,9 @@ var defaultContext = {
   }
 };
 export {
-  visitPartial,
   visit,
   typeOf,
+  toLineColumn,
   exports_time as time,
   exports_string as string,
   parse,
@@ -3043,6 +3201,7 @@ export {
   generate,
   extractInputVariables,
   extractAssignedVariables,
+  evaluateWithScope,
   evaluateScope,
   evaluate,
   defaultContext,
@@ -3060,5 +3219,6 @@ export {
   assertBoolean,
   assertArray,
   exports_array as array,
+  ParseError,
   NodeKind
 };