@almadar/evaluator 2.12.2 → 2.13.0

package/dist/index.js

@@ -733,6 +733,50 @@ function evalMathDefault(args, evaluate2, ctx) {
   }
   return n;
 }
+function evalMathSin(args, evaluate2, ctx) {
+  return Math.sin(evaluate2(args[0], ctx));
+}
+function evalMathCos(args, evaluate2, ctx) {
+  return Math.cos(evaluate2(args[0], ctx));
+}
+function evalMathTan(args, evaluate2, ctx) {
+  return Math.tan(evaluate2(args[0], ctx));
+}
+function evalMathAtan2(args, evaluate2, ctx) {
+  const y = evaluate2(args[0], ctx);
+  const x = evaluate2(args[1], ctx);
+  return Math.atan2(y, x);
+}
+function evalMathHypot(args, evaluate2, ctx) {
+  const a = evaluate2(args[0], ctx);
+  const b = evaluate2(args[1], ctx);
+  return Math.hypot(a, b);
+}
+function evalMathDegRad(args, evaluate2, ctx) {
+  return evaluate2(args[0], ctx) * (Math.PI / 180);
+}
+function evalMathRadDeg(args, evaluate2, ctx) {
+  return evaluate2(args[0], ctx) * (180 / Math.PI);
+}
+function evalMathWrap(args, evaluate2, ctx) {
+  const v = evaluate2(args[0], ctx);
+  const min = evaluate2(args[1], ctx);
+  const max = evaluate2(args[2], ctx);
+  const r = max - min;
+  if (r <= 0) {
+    return min;
+  }
+  return min + ((v - min) % r + r) % r;
+}
+function evalMathApproach(args, evaluate2, ctx) {
+  const cur = evaluate2(args[0], ctx);
+  const target = evaluate2(args[1], ctx);
+  const maxD = evaluate2(args[2], ctx);
+  if (Math.abs(target - cur) <= maxD) {
+    return target;
+  }
+  return cur + Math.sign(target - cur) * maxD;
+}
 
 // std/str.ts
 function evalStrLen(args, evaluate2, ctx) {
@@ -2575,6 +2619,454 @@ function evalAgentSearchCode(args, evaluate2, ctx) {
   return ctx.agent.searchCode(query, language);
 }
 
+// std/vector.ts
+function asVec(v) {
+  const o = v ?? {};
+  const x = typeof o.x === "number" ? o.x : 0;
+  const y = typeof o.y === "number" ? o.y : 0;
+  const z2 = typeof o.z === "number" ? o.z : void 0;
+  return z2 === void 0 ? { x, y } : { x, y, z: z2 };
+}
+function has3(v) {
+  return v.z !== void 0;
+}
+function z(v) {
+  return v.z ?? 0;
+}
+function make(x, y, zVal, is3d) {
+  return is3d ? { x, y, z: zVal } : { x, y };
+}
+function evalVecAdd(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  return make(a.x + b.x, a.y + b.y, z(a) + z(b), has3(a));
+}
+function evalVecSub(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  return make(a.x - b.x, a.y - b.y, z(a) - z(b), has3(a));
+}
+function evalVecScale(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const k = evaluate2(args[1], ctx);
+  return make(a.x * k, a.y * k, z(a) * k, has3(a));
+}
+function evalVecDot(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  return a.x * b.x + a.y * b.y + z(a) * z(b);
+}
+function evalVecCross(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  if (has3(a)) {
+    const ax = a.x, ay = a.y, az = z(a);
+    const bx = b.x, by = b.y, bz = z(b);
+    return { x: ay * bz - az * by, y: az * bx - ax * bz, z: ax * by - ay * bx };
+  }
+  return a.x * b.y - a.y * b.x;
+}
+function evalVecLength(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  return Math.sqrt(a.x * a.x + a.y * a.y + z(a) * z(a));
+}
+function evalVecLengthSq(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  return a.x * a.x + a.y * a.y + z(a) * z(a);
+}
+function evalVecNormalize(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const len = Math.sqrt(a.x * a.x + a.y * a.y + z(a) * z(a));
+  if (len === 0) {
+    return make(0, 0, 0, has3(a));
+  }
+  return make(a.x / len, a.y / len, z(a) / len, has3(a));
+}
+function evalVecDistance(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  const dx = a.x - b.x, dy = a.y - b.y, dz = z(a) - z(b);
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function evalVecDistanceSq(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  const dx = a.x - b.x, dy = a.y - b.y, dz = z(a) - z(b);
+  return dx * dx + dy * dy + dz * dz;
+}
+function evalVecLerp(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  const t = evaluate2(args[2], ctx);
+  return make(
+    a.x + (b.x - a.x) * t,
+    a.y + (b.y - a.y) * t,
+    z(a) + (z(b) - z(a)) * t,
+    has3(a)
+  );
+}
+function evalVecAngle(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  if (args.length < 2) {
+    return Math.atan2(a.y, a.x);
+  }
+  const b = asVec(evaluate2(args[1], ctx));
+  const la = Math.sqrt(a.x * a.x + a.y * a.y + z(a) * z(a));
+  const lb = Math.sqrt(b.x * b.x + b.y * b.y + z(b) * z(b));
+  if (la === 0 || lb === 0) {
+    return 0;
+  }
+  const d = (a.x * b.x + a.y * b.y + z(a) * z(b)) / (la * lb);
+  const clamped = Math.min(Math.max(d, -1), 1);
+  return Math.acos(clamped);
+}
+function evalVecRotate(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const rad = evaluate2(args[1], ctx);
+  const c = Math.cos(rad), s = Math.sin(rad);
+  return make(a.x * c - a.y * s, a.x * s + a.y * c, z(a), has3(a));
+}
+function evalVecClampLength(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const max = evaluate2(args[1], ctx);
+  const len = Math.sqrt(a.x * a.x + a.y * a.y + z(a) * z(a));
+  if (len > max) {
+    if (len === 0) {
+      return make(0, 0, 0, has3(a));
+    }
+    const k = max / len;
+    return make(a.x * k, a.y * k, z(a) * k, has3(a));
+  }
+  return make(a.x, a.y, z(a), has3(a));
+}
+
+// std/geo.ts
+function num(o, k) {
+  return typeof o[k] === "number" ? o[k] : 0;
+}
+function asVec2(v) {
+  const o = v ?? {};
+  const z2 = typeof o.z === "number" ? o.z : void 0;
+  return z2 === void 0 ? { x: num(o, "x"), y: num(o, "y") } : { x: num(o, "x"), y: num(o, "y"), z: z2 };
+}
+function asRect(v) {
+  const o = v ?? {};
+  return { x: num(o, "x"), y: num(o, "y"), w: num(o, "w"), h: num(o, "h") };
+}
+function asCircle(v) {
+  const o = v ?? {};
+  return { x: num(o, "x"), y: num(o, "y"), r: num(o, "r") };
+}
+function asSegment(v) {
+  const o = v ?? {};
+  return { x1: num(o, "x1"), y1: num(o, "y1"), x2: num(o, "x2"), y2: num(o, "y2") };
+}
+function clamp(n, lo, hi) {
+  return Math.min(Math.max(n, lo), hi);
+}
+function evalGeoAabbOverlap(args, evaluate2, ctx) {
+  const a = asRect(evaluate2(args[0], ctx));
+  const b = asRect(evaluate2(args[1], ctx));
+  return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+}
+function evalGeoCircleOverlap(args, evaluate2, ctx) {
+  const a = asCircle(evaluate2(args[0], ctx));
+  const b = asCircle(evaluate2(args[1], ctx));
+  const dx = a.x - b.x, dy = a.y - b.y;
+  return Math.sqrt(dx * dx + dy * dy) <= a.r + b.r;
+}
+function evalGeoRectCircleOverlap(args, evaluate2, ctx) {
+  const r = asRect(evaluate2(args[0], ctx));
+  const c = asCircle(evaluate2(args[1], ctx));
+  const cx = clamp(c.x, r.x, r.x + r.w);
+  const cy = clamp(c.y, r.y, r.y + r.h);
+  const dx = c.x - cx, dy = c.y - cy;
+  return dx * dx + dy * dy <= c.r * c.r;
+}
+function evalGeoPointInRect(args, evaluate2, ctx) {
+  const p = asVec2(evaluate2(args[0], ctx));
+  const r = asRect(evaluate2(args[1], ctx));
+  return p.x >= r.x && p.x <= r.x + r.w && p.y >= r.y && p.y <= r.y + r.h;
+}
+function evalGeoPointInCircle(args, evaluate2, ctx) {
+  const p = asVec2(evaluate2(args[0], ctx));
+  const c = asCircle(evaluate2(args[1], ctx));
+  const dx = p.x - c.x, dy = p.y - c.y;
+  return dx * dx + dy * dy <= c.r * c.r;
+}
+function evalGeoReflect(args, evaluate2, ctx) {
+  const v = asVec2(evaluate2(args[0], ctx));
+  const n = asVec2(evaluate2(args[1], ctx));
+  const is3d = v.z !== void 0;
+  const vz = v.z ?? 0, nz = n.z ?? 0;
+  const d = v.x * n.x + v.y * n.y + vz * nz;
+  const rx = v.x - n.x * 2 * d;
+  const ry = v.y - n.y * 2 * d;
+  const rz = vz - nz * 2 * d;
+  return is3d ? { x: rx, y: ry, z: rz } : { x: rx, y: ry };
+}
+function evalGeoSegmentIntersect(args, evaluate2, ctx) {
+  const s1 = asSegment(evaluate2(args[0], ctx));
+  const s2 = asSegment(evaluate2(args[1], ctx));
+  const r_x = s1.x2 - s1.x1, r_y = s1.y2 - s1.y1;
+  const s_x = s2.x2 - s2.x1, s_y = s2.y2 - s2.y1;
+  const denom = r_x * s_y - r_y * s_x;
+  if (denom === 0) {
+    return null;
+  }
+  const qpx = s2.x1 - s1.x1, qpy = s2.y1 - s1.y1;
+  const t = (qpx * s_y - qpy * s_x) / denom;
+  const u = (qpx * r_y - qpy * r_x) / denom;
+  if (t < 0 || t > 1 || u < 0 || u > 1) {
+    return null;
+  }
+  return { x: s1.x1 + t * r_x, y: s1.y1 + t * r_y };
+}
+
+// std/grid.ts
+function num2(o, k) {
+  return typeof o[k] === "number" ? o[k] : 0;
+}
+function asCell(v) {
+  const o = v ?? {};
+  return { x: num2(o, "x"), y: num2(o, "y") };
+}
+function evalGridToWorld(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const cellSize = evaluate2(args[1], ctx);
+  return { x: (cell.x + 0.5) * cellSize, y: (cell.y + 0.5) * cellSize };
+}
+function evalGridFromWorld(args, evaluate2, ctx) {
+  const point = asCell(evaluate2(args[0], ctx));
+  const cellSize = evaluate2(args[1], ctx);
+  return { x: Math.floor(point.x / cellSize), y: Math.floor(point.y / cellSize) };
+}
+function evalGridIsoToScreen(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const tileW = evaluate2(args[1], ctx);
+  const tileH = evaluate2(args[2], ctx);
+  return { x: (cell.x - cell.y) * tileW / 2, y: (cell.x + cell.y) * tileH / 2 };
+}
+function evalGridScreenToIso(args, evaluate2, ctx) {
+  const point = asCell(evaluate2(args[0], ctx));
+  const tileW = evaluate2(args[1], ctx);
+  const tileH = evaluate2(args[2], ctx);
+  const halfW = tileW / 2;
+  const halfH = tileH / 2;
+  return {
+    x: (point.x / halfW + point.y / halfH) / 2,
+    y: (point.y / halfH - point.x / halfW) / 2
+  };
+}
+function evalGridDistance(args, evaluate2, ctx) {
+  const a = asCell(evaluate2(args[0], ctx));
+  const b = asCell(evaluate2(args[1], ctx));
+  return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y));
+}
+function evalGridManhattanDistance(args, evaluate2, ctx) {
+  const a = asCell(evaluate2(args[0], ctx));
+  const b = asCell(evaluate2(args[1], ctx));
+  return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+}
+function evalGridNeighbors(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const diagonal = args.length > 1 ? Boolean(evaluate2(args[1], ctx)) : false;
+  const result = [
+    { x: cell.x, y: cell.y - 1 },
+    // N
+    { x: cell.x + 1, y: cell.y },
+    // E
+    { x: cell.x, y: cell.y + 1 },
+    // S
+    { x: cell.x - 1, y: cell.y }
+    // W
+  ];
+  if (diagonal) {
+    result.push(
+      { x: cell.x + 1, y: cell.y - 1 },
+      // NE
+      { x: cell.x + 1, y: cell.y + 1 },
+      // SE
+      { x: cell.x - 1, y: cell.y + 1 },
+      // SW
+      { x: cell.x - 1, y: cell.y - 1 }
+      // NW
+    );
+  }
+  return result;
+}
+function evalGridCellsInRadius(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const r = evaluate2(args[1], ctx);
+  const rf = Math.floor(r);
+  const r2 = r * r;
+  const result = [];
+  for (let dy = -rf; dy <= rf; dy++) {
+    for (let dx = -rf; dx <= rf; dx++) {
+      if (dx * dx + dy * dy <= r2) {
+        result.push({ x: cell.x + dx, y: cell.y + dy });
+      }
+    }
+  }
+  return result;
+}
+function evalGridLine(args, evaluate2, ctx) {
+  const a = asCell(evaluate2(args[0], ctx));
+  const b = asCell(evaluate2(args[1], ctx));
+  let x0 = a.x, y0 = a.y;
+  const x1 = b.x, y1 = b.y;
+  const dx = Math.abs(x1 - x0);
+  const dy = Math.abs(y1 - y0);
+  const sx = x0 < x1 ? 1 : -1;
+  const sy = y0 < y1 ? 1 : -1;
+  let err = dx - dy;
+  const result = [];
+  for (; ; ) {
+    result.push({ x: x0, y: y0 });
+    if (x0 === x1 && y0 === y1) {
+      break;
+    }
+    const e2 = 2 * err;
+    if (e2 > -dy) {
+      err -= dy;
+      x0 += sx;
+    }
+    if (e2 < dx) {
+      err += dx;
+      y0 += sy;
+    }
+  }
+  return result;
+}
+function evalGridInBounds(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const w = evaluate2(args[1], ctx);
+  const h = evaluate2(args[2], ctx);
+  return cell.x >= 0 && cell.x < w && cell.y >= 0 && cell.y < h;
+}
+
+// std/anim.ts
+function evalAnimFrameAt(args, evaluate2, ctx) {
+  const elapsed = evaluate2(args[0], ctx);
+  const frameDur = evaluate2(args[1], ctx);
+  const frameCount = evaluate2(args[2], ctx);
+  const loop = args.length > 3 ? Boolean(evaluate2(args[3], ctx)) : true;
+  if (frameCount <= 0) {
+    return 0;
+  }
+  const i = Math.floor(elapsed / frameDur);
+  if (loop) {
+    return (i % frameCount + frameCount) % frameCount;
+  }
+  return Math.min(i, frameCount - 1);
+}
+function evalAnimSheetRect(args, evaluate2, ctx) {
+  const frameIndex = evaluate2(args[0], ctx);
+  const cols = evaluate2(args[1], ctx);
+  const frameW = evaluate2(args[2], ctx);
+  const frameH = evaluate2(args[3], ctx);
+  return {
+    sx: frameIndex % cols * frameW,
+    sy: Math.floor(frameIndex / cols) * frameH,
+    sw: frameW,
+    sh: frameH
+  };
+}
+function evalAnimDirectionFromDelta(args, evaluate2, ctx) {
+  const dx = evaluate2(args[0], ctx);
+  const dy = evaluate2(args[1], ctx);
+  const ways = args.length > 2 ? evaluate2(args[2], ctx) : 4;
+  const angle = Math.atan2(dy, dx);
+  if (ways === 8) {
+    const sector2 = Math.round(angle / (Math.PI / 4));
+    const idx2 = (sector2 % 8 + 8) % 8;
+    const dirs8 = [
+      "right",
+      "down-right",
+      "down",
+      "down-left",
+      "left",
+      "up-left",
+      "up",
+      "up-right"
+    ];
+    return dirs8[idx2];
+  }
+  const sector = Math.round(angle / (Math.PI / 2));
+  const idx = (sector % 4 + 4) % 4;
+  const dirs4 = ["right", "down", "left", "up"];
+  return dirs4[idx];
+}
+
+// std/ease.ts
+function clamp01(t) {
+  return Math.min(Math.max(t, 0), 1);
+}
+function applyCurve(curve, tRaw) {
+  const t = clamp01(tRaw);
+  switch (curve) {
+    case "in-quad":
+      return t * t;
+    case "out-quad":
+      return t * (2 - t);
+    case "in-out-quad":
+      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    case "in-cubic":
+      return t * t * t;
+    case "out-cubic": {
+      const u = t - 1;
+      return u * u * u + 1;
+    }
+    case "in-out-cubic":
+      return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+    case "elastic-out": {
+      if (t === 0) {
+        return 0;
+      }
+      if (t === 1) {
+        return 1;
+      }
+      const c4 = 2 * Math.PI / 3;
+      return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1;
+    }
+    case "bounce-out": {
+      const n1 = 7.5625;
+      const d1 = 2.75;
+      let u = t;
+      if (u < 1 / d1) {
+        return n1 * u * u;
+      } else if (u < 2 / d1) {
+        u -= 1.5 / d1;
+        return n1 * u * u + 0.75;
+      } else if (u < 2.5 / d1) {
+        u -= 2.25 / d1;
+        return n1 * u * u + 0.9375;
+      } else {
+        u -= 2.625 / d1;
+        return n1 * u * u + 0.984375;
+      }
+    }
+    case "linear":
+    default:
+      return t;
+  }
+}
+function evalEaseApply(args, evaluate2, ctx) {
+  const curve = evaluate2(args[0], ctx);
+  const t = evaluate2(args[1], ctx);
+  return applyCurve(curve, t);
+}
+function evalEaseSmoothstep(args, evaluate2, ctx) {
+  const edge0 = evaluate2(args[0], ctx);
+  const edge1 = evaluate2(args[1], ctx);
+  const x = evaluate2(args[2], ctx);
+  if (edge0 === edge1) {
+    return 0;
+  }
+  const t = clamp01((x - edge0) / (edge1 - edge0));
+  return t * t * (3 - 2 * t);
+}
+
 // SExpressionEvaluator.ts
 var jitCache = /* @__PURE__ */ new Map();
 var MAX_JIT_CACHE_SIZE = 1e3;
@@ -2841,6 +3333,111 @@ var SExpressionEvaluator = class {
         return evalMathRandomInt(args, evaluate2, ctx);
       case "math/default":
         return evalMathDefault(args, evaluate2, ctx);
+      case "math/sin":
+        return evalMathSin(args, evaluate2, ctx);
+      case "math/cos":
+        return evalMathCos(args, evaluate2, ctx);
+      case "math/tan":
+        return evalMathTan(args, evaluate2, ctx);
+      case "math/atan2":
+        return evalMathAtan2(args, evaluate2, ctx);
+      case "math/hypot":
+        return evalMathHypot(args, evaluate2, ctx);
+      case "math/deg-rad":
+        return evalMathDegRad(args, evaluate2, ctx);
+      case "math/rad-deg":
+        return evalMathRadDeg(args, evaluate2, ctx);
+      case "math/wrap":
+        return evalMathWrap(args, evaluate2, ctx);
+      case "math/approach":
+        return evalMathApproach(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: vec/*
+      // ===============================
+      case "vec/add":
+        return evalVecAdd(args, evaluate2, ctx);
+      case "vec/sub":
+        return evalVecSub(args, evaluate2, ctx);
+      case "vec/scale":
+        return evalVecScale(args, evaluate2, ctx);
+      case "vec/dot":
+        return evalVecDot(args, evaluate2, ctx);
+      case "vec/cross":
+        return evalVecCross(args, evaluate2, ctx);
+      case "vec/length":
+        return evalVecLength(args, evaluate2, ctx);
+      case "vec/length-sq":
+        return evalVecLengthSq(args, evaluate2, ctx);
+      case "vec/normalize":
+        return evalVecNormalize(args, evaluate2, ctx);
+      case "vec/distance":
+        return evalVecDistance(args, evaluate2, ctx);
+      case "vec/distance-sq":
+        return evalVecDistanceSq(args, evaluate2, ctx);
+      case "vec/lerp":
+        return evalVecLerp(args, evaluate2, ctx);
+      case "vec/angle":
+        return evalVecAngle(args, evaluate2, ctx);
+      case "vec/rotate":
+        return evalVecRotate(args, evaluate2, ctx);
+      case "vec/clamp-length":
+        return evalVecClampLength(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: geo/*
+      // ===============================
+      case "geo/aabb-overlap":
+        return evalGeoAabbOverlap(args, evaluate2, ctx);
+      case "geo/circle-overlap":
+        return evalGeoCircleOverlap(args, evaluate2, ctx);
+      case "geo/rect-circle-overlap":
+        return evalGeoRectCircleOverlap(args, evaluate2, ctx);
+      case "geo/point-in-rect":
+        return evalGeoPointInRect(args, evaluate2, ctx);
+      case "geo/point-in-circle":
+        return evalGeoPointInCircle(args, evaluate2, ctx);
+      case "geo/reflect":
+        return evalGeoReflect(args, evaluate2, ctx);
+      case "geo/segment-intersect":
+        return evalGeoSegmentIntersect(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: grid/*
+      // ===============================
+      case "grid/to-world":
+        return evalGridToWorld(args, evaluate2, ctx);
+      case "grid/from-world":
+        return evalGridFromWorld(args, evaluate2, ctx);
+      case "grid/iso-to-screen":
+        return evalGridIsoToScreen(args, evaluate2, ctx);
+      case "grid/screen-to-iso":
+        return evalGridScreenToIso(args, evaluate2, ctx);
+      case "grid/distance":
+        return evalGridDistance(args, evaluate2, ctx);
+      case "grid/manhattan-distance":
+        return evalGridManhattanDistance(args, evaluate2, ctx);
+      case "grid/neighbors":
+        return evalGridNeighbors(args, evaluate2, ctx);
+      case "grid/cells-in-radius":
+        return evalGridCellsInRadius(args, evaluate2, ctx);
+      case "grid/line":
+        return evalGridLine(args, evaluate2, ctx);
+      case "grid/in-bounds":
+        return evalGridInBounds(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: anim/*
+      // ===============================
+      case "anim/frame-at":
+        return evalAnimFrameAt(args, evaluate2, ctx);
+      case "anim/sheet-rect":
+        return evalAnimSheetRect(args, evaluate2, ctx);
+      case "anim/direction-from-delta":
+        return evalAnimDirectionFromDelta(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: ease/*
+      // ===============================
+      case "ease/apply":
+        return evalEaseApply(args, evaluate2, ctx);
+      case "ease/smoothstep":
+        return evalEaseSmoothstep(args, evaluate2, ctx);
       // ===============================
       // Standard Library: str/*
       // ===============================