littlewing 2.2.0 → 2.3.2

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,74 +338,110 @@ 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);
@@ -707,21 +740,25 @@ function lexIdentifier(cursor) {
 
 // src/utils.ts
 function typeOf(value) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null)
+    return "null";
   if (typeof value === "number")
     return "number";
   if (typeof value === "string")
     return "string";
   if (typeof value === "boolean")
     return "boolean";
+  if (Array.isArray(value))
+    return "array";
   if (value instanceof Temporal.PlainDateTime)
     return "datetime";
   if (value instanceof Temporal.PlainDate)
     return "date";
   if (value instanceof Temporal.PlainTime)
     return "time";
-  if (Array.isArray(value))
-    return "array";
-  throw new Error(`Unknown runtime value type`);
+  return typeof value;
 }
 function deepEquals(a, b) {
   if (typeof a === "number" && typeof b === "number")
@@ -758,6 +795,13 @@ function assertNumber(v, context, side) {
     throw new TypeError(`${context}${where} expected number, got ${typeOf(v)}`);
   }
 }
+function assertInteger(v, context, side) {
+  assertNumber(v, context, side);
+  if (!Number.isInteger(v)) {
+    const where = side ? ` (${side})` : "";
+    throw new TypeError(`${context}${where} expected integer, got ${v}`);
+  }
+}
 function assertBoolean(v, context, side) {
   if (typeof v !== "boolean") {
     const where = side ? ` (${side})` : "";
@@ -815,7 +859,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) {
@@ -919,13 +973,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;
@@ -945,11 +1015,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) {
@@ -979,69 +1045,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 */:
@@ -1139,90 +1211,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([
@@ -1612,198 +1682,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);
+          variables.delete(node2.variable);
         }
-        restoreLoopVar();
-        return acc;
+        validateHomogeneousArray(result);
+        return result;
       }
-      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;
-        }
-        result.push(recurse(n.body));
-      }
-      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) {
@@ -1869,24 +1965,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;
@@ -1917,10 +2023,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;
@@ -1938,221 +2043,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);
@@ -2179,142 +2293,188 @@ 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);
+      if (node.operator === "&&") {
+        if (isBooleanLiteral(left) && !left.value) {
+          return preserveComments(node, boolean(false));
+        }
+        const right2 = recurse(node.right);
+        if (isBooleanLiteral(left) && isBooleanLiteral(right2)) {
+          return preserveComments(node, boolean(right2.value));
+        }
+        if (left === node.left && right2 === node.right)
+          return node;
+        return preserveComments(node, binaryOp(left, node.operator, right2));
+      }
+      if (node.operator === "||") {
+        if (isBooleanLiteral(left) && left.value) {
+          return preserveComments(node, boolean(true));
+        }
+        const right2 = recurse(node.right);
+        if (isBooleanLiteral(left) && isBooleanLiteral(right2)) {
+          return preserveComments(node, boolean(right2.value));
+        }
+        if (left === node.left && right2 === node.right)
+          return node;
+        return preserveComments(node, binaryOp(left, node.operator, right2));
+      }
+      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 (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 = {};
@@ -2330,7 +2490,7 @@ __export(exports_array, {
 var ARR_SORT = (a) => {
   assertArray(a, "ARR_SORT");
   if (a.length <= 1)
-    return a;
+    return [...a];
   const sorted = [...a];
   const elemType = typeOf(sorted[0]);
   sorted.sort((x, y) => {
@@ -2499,8 +2659,63 @@ function assertStringOrArray(v, context) {
     throw new TypeError(`${context} expected string or array, got ${typeOf(v)}`);
   }
 }
+function hasSurrogateCodeUnit(value) {
+  for (let i = 0;i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 57343)
+      return true;
+  }
+  return false;
+}
+function codePointLength(value) {
+  let length = 0;
+  for (let i = 0;i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319 && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343)
+        i++;
+    }
+    length++;
+  }
+  return length;
+}
+function stringLength(value) {
+  return hasSurrogateCodeUnit(value) ? codePointLength(value) : value.length;
+}
+function sliceString(value, start, end) {
+  if (!hasSurrogateCodeUnit(value))
+    return value.slice(start, end);
+  return Array.from(value).slice(start, end).join("");
+}
+function indexOfString(value, search) {
+  if (search === "")
+    return 0;
+  if (!hasSurrogateCodeUnit(value) && !hasSurrogateCodeUnit(search)) {
+    return value.indexOf(search);
+  }
+  const haystack = Array.from(value);
+  const needle = Array.from(search);
+  if (needle.length > haystack.length)
+    return -1;
+  const limit = haystack.length - needle.length;
+  for (let i = 0;i <= limit; i++) {
+    let found = true;
+    for (let j = 0;j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) {
+        found = false;
+        break;
+      }
+    }
+    if (found)
+      return i;
+  }
+  return -1;
+}
 var LEN = (v) => {
   assertStringOrArray(v, "LEN");
+  if (typeof v === "string")
+    return stringLength(v);
   return v.length;
 };
 var SLICE = (v, start, end) => {
@@ -2508,8 +2723,12 @@ var SLICE = (v, start, end) => {
   assertNumber(start, "SLICE", "start");
   if (end !== undefined) {
     assertNumber(end, "SLICE", "end");
+    if (typeof v === "string")
+      return sliceString(v, start, end);
     return v.slice(start, end);
   }
+  if (typeof v === "string")
+    return sliceString(v, start);
   return v.slice(start);
 };
 var CONTAINS = (v, search) => {
@@ -2535,7 +2754,7 @@ var INDEX_OF = (v, search) => {
   assertStringOrArray(v, "INDEX_OF");
   if (typeof v === "string") {
     assertString(search, "INDEX_OF (search)");
-    return v.indexOf(search);
+    return indexOfString(v, search);
   }
   for (let i = 0;i < v.length; i++) {
     if (deepEquals(v[i], search))
@@ -2575,9 +2794,9 @@ __export(exports_datetime, {
 });
 var TODAY = () => Temporal.Now.plainDateISO();
 var DATE = (year, month, day) => {
-  assertNumber(year, "DATE", "year");
-  assertNumber(month, "DATE", "month");
-  assertNumber(day, "DATE", "day");
+  assertInteger(year, "DATE", "year");
+  assertInteger(month, "DATE", "month");
+  assertInteger(day, "DATE", "day");
   return new Temporal.PlainDate(year, month, day);
 };
 var YEAR = (date) => {
@@ -2745,12 +2964,12 @@ __export(exports_datetimefull, {
   COMBINE: () => COMBINE
 });
 var DATETIME = (year, month, day, hour, minute, second) => {
-  assertNumber(year, "DATETIME", "year");
-  assertNumber(month, "DATETIME", "month");
-  assertNumber(day, "DATETIME", "day");
-  assertNumber(hour, "DATETIME", "hour");
-  assertNumber(minute, "DATETIME", "minute");
-  assertNumber(second, "DATETIME", "second");
+  assertInteger(year, "DATETIME", "year");
+  assertInteger(month, "DATETIME", "month");
+  assertInteger(day, "DATETIME", "day");
+  assertInteger(hour, "DATETIME", "hour");
+  assertInteger(minute, "DATETIME", "minute");
+  assertInteger(second, "DATETIME", "second");
   return new Temporal.PlainDateTime(year, month, day, hour, minute, second);
 };
 var NOW = () => Temporal.Now.plainDateTimeISO();
@@ -2829,12 +3048,18 @@ var SQRT = (x) => {
   return Math.sqrt(x);
 };
 var MIN = (...values) => {
+  if (values.length === 0) {
+    throw new RangeError("MIN requires at least one argument");
+  }
   for (const value of values) {
     assertNumber(value, "MIN");
   }
   return Math.min(...values);
 };
 var MAX = (...values) => {
+  if (values.length === 0) {
+    throw new RangeError("MAX requires at least one argument");
+  }
   for (const value of values) {
     assertNumber(value, "MAX");
   }
@@ -2868,6 +3093,9 @@ var CLAMP = (value, min, max) => {
   assertNumber(value, "CLAMP", "value");
   assertNumber(min, "CLAMP", "min");
   assertNumber(max, "CLAMP", "max");
+  if (min > max) {
+    throw new RangeError(`CLAMP: min (${min}) must not exceed max (${max})`);
+  }
   return value < min ? min : value > max ? max : value;
 };
 
@@ -2943,9 +3171,9 @@ __export(exports_time, {
   ADD_HOURS: () => ADD_HOURS
 });
 var TIME = (hour, minute, second) => {
-  assertNumber(hour, "TIME", "hour");
-  assertNumber(minute, "TIME", "minute");
-  assertNumber(second, "TIME", "second");
+  assertInteger(hour, "TIME", "hour");
+  assertInteger(minute, "TIME", "minute");
+  assertInteger(second, "TIME", "second");
   return new Temporal.PlainTime(hour, minute, second);
 };
 var NOW_TIME = () => Temporal.Now.plainTimeISO();
@@ -3045,7 +3273,6 @@ var defaultContext = {
   }
 };
 export {
-  visitPartial,
   visit,
   typeOf,
   toLineColumn,
@@ -3073,6 +3300,7 @@ export {
   generate,
   extractInputVariables,
   extractAssignedVariables,
+  evaluateWithScope,
   evaluateScope,
   evaluate,
   defaultContext,