@shwfed/config 2.12.4 → 2.12.6

package/dist/runtime/vendor/cel-js/PROMPT.md

@@ -8,7 +8,7 @@ CEL has these types:
 
 | Type | Examples | Notes |
 |------|----------|-------|
-| `number` | `42`, `3.14`, `0xFF` | All numbers are arbitrary-precision decimals. There is no `int`, `uint`, or `float` distinction — just `number`. `0.1 + 0.2 == 0.3` is `true`. |
+| `number` | `42`, `3.14`, `0xFF` | All numbers are arbitrary-precision decimals. There is no `int`, `uint`, or `float` distinction — just `number`. `0.1 + 0.2 == 0.3` is `true`. Division keeps 20 significant digits, so `10 / 3 * 3 == 10` is `false` — compare against a rounded value instead. |
 | `string` | `"hello"`, `'world'` | Single or double quotes. Triple-quoted for multiline: `"""text"""`. Raw strings: `r"no\escapes"`. |
 | `bool` | `true`, `false` | |
 | `bytes` | `b"data"`, `b'\xff'` | Binary data. |
@@ -101,16 +101,33 @@ obj[?0]                     // optional index access (returns optional)
 ```cel
 number("42")               // parse string to number
 number(true)               // 1 (false gives 0)
+number(d)                  // Date → epoch-millisecond timestamp
 string(42)                 // "42"
 string(true)               // "true"
+string(d)                  // Date → ISO 8601 string
 bool("true")               // true (also accepts "t", "1", "TRUE", "True")
 bool("false")              // false (also accepts "f", "0", "FALSE", "False")
 bytes("text")              // UTF-8 encode to bytes
-int(3.7)                   // 3 (truncates to integer)
-double("3.14")             // alias for number()
 type(x)                    // returns the type of x
 dyn(x)                     // identity, marks as dynamic type
 ```
+There is no `int()`, `uint()`, or `double()` — `number` is the only numeric
+type. To produce an integer, round explicitly with `math.trunc` / `math.floor`
+/ `math.ceil` / `math.round`.
+
+### Math
+```cel
+math.trunc(3.7)            // 3  — drop the fraction (toward zero)
+math.floor(3.7)            // 3  — toward negative infinity (math.floor(-3.1) == -4)
+math.ceil(3.1)             // 4  — toward positive infinity
+math.round(2.5)            // 3  — nearest; ties away from zero (math.round(-2.5) == -3)
+math.abs(-3.5)             // 3.5
+math.min(3, 7)             // 3
+math.max(3, 7)             // 7
+math.min([5, 2, 9])        // 2  — also accepts a list<number> (errors on [])
+math.max(items.map(i, number(i.price)))   // largest mapped value
+```
+All math operations are exact decimal arithmetic — no float rounding error.
 
 ### Size
 ```cel
@@ -213,44 +230,60 @@ Value coercion is flat (same rules as `.query(...)`):
   on the value if you need a structured field)
 
 ### Dates
+Unit and field names accept singular or plural ("day" == "days") everywhere.
+
 ```cel
 date("2023-06-15")                   // create a Date
 date("2023-06-15T10:30:00Z")        // with time component
 date(1718409600)                     // from a Unix timestamp — seconds...
 date(1718409600000)                  // ...or milliseconds (unit auto-detected by magnitude)
 
-// Comparisons:
+// Time zones (IANA name or fixed offset):
+date("2024-06-15T09:00", "Asia/Shanghai")  // 09:00 *in Shanghai* (wall-clock reading)
+date(1718409600, "UTC")              // timestamp, rendered in UTC
+d.tz("America/New_York")            // same instant, rendered in another zone
+// format / get / startOf / set all work in the date's own zone.
+
+// Comparisons (instant-based, zone-independent):
 date("2023-01-01") < date("2024-01-01")   // true
 date("2023-01-01") == date("2023-01-01")  // true
 
+// Read calendar fields (numbers; month is 1-based):
+d.get("year")                        // 2023
+d.get("month")                       // 6 — June
+d.get("day")                         // day of month
+d.get("hour")                        // 0–23
+d.get("minute")  d.get("second")  d.get("millisecond")
+d.get("weekday")                     // ISO: 1 = Monday … 7 = Sunday
+
 // Start/end of period:
-d.startOf("day")                     // start of day
-d.startOf("week")                    // start of week
-d.startOf("month")                   // start of month
-d.startOf("year")                    // start of year
-d.endOf("month")                     // end of month
+d.startOf("day")                     // also: minute / hour / week / month / year
+d.endOf("month")                     // same units as startOf
 
 // Offset (positive or negative):
 d.offset(3, "days")                  // 3 days later
 d.offset(-1, "month")               // 1 month earlier
-d.offset(2, "weeks")                // 2 weeks later
-d.offset(1, "year")                 // 1 year later
+d.offset(90, "minutes")             // sub-day units work too
+// units: millisecond / second / minute / hour / day / week / month / year
 
 // Difference between two dates (signed, truncated toward zero):
 // receiver is the minuend, so `a.diff(b, unit)` == a − b
 d.diff(other, "day")                // whole days from other to d (negative if d is earlier)
 d.diff(other, "hour")              // whole hours
-d.diff(other, "minute")           // whole minutes
-// units: millisecond / second / minute / hour / day / week / month / year (plural ok)
+// units: millisecond / second / minute / hour / day / week / month / year
 
-// Set specific fields:
+// Set specific fields (month is 1-based):
 d.set("day", 15)                     // set day of month to 15
-d.set("month", 6)                    // set to June (1-based)
-d.set("year", 2025)                  // set year to 2025
+d.set("month", 6)                    // set to June
+d.set("hour", 9)                     // also: minute / second / millisecond / year
 
 // Format:
 d.format("yyyy-MM-dd")              // "2023-06-15"
 d.format("MMMM d, yyyy")           // "June 15, 2023"
+
+// Convert:
+number(d)                            // epoch-millisecond timestamp
+string(d)                            // ISO 8601 in the date's own zone
 ```
 
 ### Ranges
@@ -262,7 +295,7 @@ range(0, 10, 2)                      // [0, 2, 4, 6, 8] — with a step
 range(5, 0)                          // [5, 4, 3, 2, 1] — counts down
 range(date("2024-01-01"), date("2024-04-01"), "month")
                                      // [2024-01-01, 2024-02-01, 2024-03-01]
-// Date unit is one of: "year", "month", "day", "hour", "minute".
+// Date unit is one of: second / minute / hour / day / week / month / year (plural ok).
 ```
 
 ### URL
@@ -336,10 +369,13 @@ http.post("https://api.example.com/users")
 
 An `optional<T>` is either present (`Some`) or absent (`None`). They come from
 `.?` / `[?]` access, `find`, and `URL.query`. Build them with `optional.of(x)`
-(the lift — wraps a value as present) and `optional.none()`.
+(the lift — wraps a value as present), `optional.ofNullable(x)` (like `of`, but
+`null` lifts to absent), and `optional.none()`.
 
 ```cel
 optional.of(5)                          // present, holds 5
+optional.of(null)                       // present, holds null (of never inspects the value)
+optional.ofNullable(row.middleName)     // absent when the field is null
 optional.none()                         // absent
 
 o.hasValue()                            // bool — is it present?
@@ -370,6 +406,48 @@ optional.of(2).flatMap(v, optional.none()).hasValue()   // false — body collap
 Together with `optional.of`, `flatMap` is a lawful monad and `map` its derived
 Functor (`o.map(v, body)` == `o.flatMap(v, optional.of(body))`).
 
+### filter — keep a present value only if it qualifies
+`o.filter(v, predicate)` keeps a present value when the predicate holds and
+collapses it to `None` otherwise; an absent `o` stays `None` and the predicate
+is never evaluated. The value is unchanged — `filter` never transforms.
+```cel
+loc.query("tab").filter(v, v != "").orValue("home")
+// drop a present-but-empty ?tab= and fall back to "home"
+
+optional.of(5).filter(v, v > 10).hasValue()   // false — value didn't qualify
+```
+
+### exists / all — test a present value without unwrapping
+`o.exists(v, predicate)` is the predicate when present, `false` when absent.
+`o.all(v, predicate)` is the predicate when present, `true` when absent
+(vacuous truth — "no value violates it"). Both return plain `bool`, so they
+slot directly into conditions.
+```cel
+query.?channel.exists(c, c == "web")     // false when the field is absent
+query.?limit.all(l, l <= 100)            // absent limit is fine; a present one must qualify
+```
+
+### zip — combine two optionals
+`a.zip(b, x, y, body)` binds the present value of `a` to `x`, the present value
+of `b` to `y`, evaluates `body` (a plain value), and re-wraps the result as
+present — but only when **both** are present; if either is absent the result is
+`None` and `body` is never evaluated. It is the flattened form of
+`a.flatMap(x, b.map(y, body))` — use it to apply a two-argument operation
+(logical `&&`/`||`, string concatenation, arithmetic) across two optionals
+without nesting.
+```cel
+// logical AND of two optional booleans
+enabled.zip(allowed, e, a, e && a).orValue(false)
+
+// concatenate two optional strings, with a fallback
+first.zip(last, f, l, f + " " + l).orValue("N/A")
+```
+Note this is applicative, not three-valued: `optional.of(false).zip(none, a, b, a && b)`
+is `None`, not `Some(false)` — a determined operand does not rescue an absent one.
+Only reach for `zip` when **both** operands are optional; if just one is, plain
+`map` suffices (`a.map(x, x && plainBool)`). For three or more, chain it:
+`a.zip(b, x, y, x && y).zip(c, r, z, r && z)`.
+
 ## Macros
 
 Macros are special forms — they look like method calls but have special evaluation semantics.
@@ -463,7 +541,7 @@ values.all(v, v >= 0 && v <= 100)
 - **No function definitions** — You can only call built-in or registered functions.
 - **No statements** — No `if`/`else` blocks, `for`, `while`, `return`. Use the ternary `? :` for conditionals.
 - **No mutation** — You cannot modify values. Every operation produces a new value.
-- **No `int` or `uint` type** — All numbers are just `number`. Write `42`, not `int(42)`. You do not need to worry about integer vs float precision — `0.1 + 0.2 == 0.3` works correctly.
+- **No `int`, `uint`, or `double`** — All numbers are just `number`, and the `int()` / `uint()` / `double()` conversions do not exist (calling them is an error, and a `123u` literal is a parse error). You do not need to worry about integer vs float precision — `0.1 + 0.2 == 0.3` works correctly. To force an integer, round explicitly: `math.trunc(x)`, `math.floor(x)`, `math.ceil(x)`, or `math.round(x)`.
 - **No imports or modules** — Everything available is already in scope.
 
 ## Error Cases to Avoid

package/dist/runtime/vendor/cel-js/lib/decimal.d.ts

@@ -6,6 +6,10 @@ export declare class Decimal {
     constructor(sign: 1 | -1, coeff: bigint, exp: number);
     static from(v: DecimalInput): Decimal;
     isZero(): boolean;
+    trunc(): Decimal;
+    floor(): Decimal;
+    ceil(): Decimal;
+    round(): Decimal;
     isInteger(): boolean;
     neg(): Decimal;
     abs(): Decimal;

package/dist/runtime/vendor/cel-js/lib/decimal.js

@@ -15,6 +15,29 @@ function normalize(sign, coeff, exp) {
   }
   return new Decimal(sign, coeff, exp);
 }
+function toInteger(d, mode) {
+  if (d.exp >= 0) return d;
+  const scale = pow10(-d.exp);
+  const q = d.coeff / scale;
+  const r = d.coeff % scale;
+  let up = false;
+  switch (mode) {
+    case "trunc":
+      break;
+    case "floor":
+      up = d.sign === -1 && r !== ZERO;
+      break;
+    case "ceil":
+      up = d.sign === 1 && r !== ZERO;
+      break;
+    case "round":
+      up = r * 2n >= scale;
+      break;
+  }
+  const coeff = up ? q + ONE : q;
+  if (coeff === ZERO) return new Decimal(1, ZERO, 0);
+  return normalize(d.sign, coeff, 0);
+}
 function alignExp(a, b) {
   const diff = a.exp - b.exp;
   if (diff === 0) return [a.coeff, b.coeff, a.exp];
@@ -90,6 +113,18 @@ export class Decimal {
   isZero() {
     return this.coeff === ZERO;
   }
+  trunc() {
+    return toInteger(this, "trunc");
+  }
+  floor() {
+    return toInteger(this, "floor");
+  }
+  ceil() {
+    return toInteger(this, "ceil");
+  }
+  round() {
+    return toInteger(this, "round");
+  }
   isInteger() {
     return this.exp >= 0;
   }

package/dist/runtime/vendor/cel-js/lib/evaluator.js

@@ -5,6 +5,7 @@ import { registerFunctions } from "./functions.js";
 import { registerHttpBuiltins } from "./http-builtins.js";
 import { registerJSONBuiltins } from "./json-builtins.js";
 import { registerFormBuiltins } from "./form-builtins.js";
+import { registerMathBuiltins } from "./math-builtins.js";
 import { registerMacros } from "./macros.js";
 import { registerOverloads } from "./overloads.js";
 import { TypeChecker } from "./type-checker.js";
@@ -18,6 +19,7 @@ registerMacros(globalRegistry);
 registerHttpBuiltins(globalRegistry);
 registerJSONBuiltins(globalRegistry);
 registerFormBuiltins(globalRegistry);
+registerMathBuiltins(globalRegistry);
 class Environment {
   #registry;
   #evaluator;

package/dist/runtime/vendor/cel-js/lib/functions.js

@@ -4,7 +4,7 @@ import { TYPES, Type } from "./registry.js";
 import { register as registerOptional, optionalOf } from "./optional.js";
 import { objKeys, arrayFrom } from "./globals.js";
 import { TZDate } from "@date-fns/tz";
-import { startOfDay, startOfWeek, startOfMonth, startOfYear, endOfDay, endOfWeek, endOfMonth, endOfYear, addDays, addWeeks, addMonths, addYears, addHours, addMinutes, setDate as setDayOfMonth, setMonth, setYear, format as formatDate, differenceInMilliseconds, differenceInSeconds, differenceInMinutes, differenceInHours, differenceInDays, differenceInWeeks, differenceInMonths, differenceInYears } from "date-fns";
+import { startOfMinute, startOfHour, startOfDay, startOfWeek, startOfMonth, startOfYear, endOfMinute, endOfHour, endOfDay, endOfWeek, endOfMonth, endOfYear, addMilliseconds, addSeconds, addMinutes, addHours, addDays, addWeeks, addMonths, addYears, setMilliseconds, setSeconds, setMinutes, setHours, setDate as setDayOfMonth, setMonth, setYear, format as formatDate, differenceInMilliseconds, differenceInSeconds, differenceInMinutes, differenceInHours, differenceInDays, differenceInWeeks, differenceInMonths, differenceInYears } from "date-fns";
 function toNum(v) {
   if (v instanceof Decimal) return v.toNumber();
   if (typeof v === "bigint") return Number(v);
@@ -82,53 +82,6 @@ export function registerFunctions(registry) {
     }
   });
   functionOverload("number(bool): number", (v) => Decimal.from(v ? 1 : 0));
-  functionOverload("int(number): number", (v) => {
-    const d = Decimal.from(v);
-    if (d.isInteger()) return d;
-    const n = d.toNumber();
-    if (!Number.isFinite(n)) throw evaluationError("numeric_overflow", "int() type error: integer overflow");
-    return Decimal.from(BigInt(Math.trunc(n)));
-  });
-  functionOverload("int(string): number", (v) => {
-    const s = v;
-    if (s !== s.trim() || s.length > 20 || s.includes("0x")) {
-      throw evaluationError("int_conversion_error", "int() type error: cannot convert to int");
-    }
-    try {
-      return Decimal.from(s);
-    } catch {
-      throw evaluationError("int_conversion_error", "int() type error: cannot convert to int");
-    }
-  });
-  functionOverload("double(number): number", (v) => Decimal.from(v));
-  functionOverload("double(string): number", (v) => {
-    const s = v;
-    if (!s || s !== s.trim())
-      throw evaluationError(
-        "double_conversion_error",
-        "double() type error: cannot convert to double"
-      );
-    try {
-      return Decimal.from(s);
-    } catch {
-      throw evaluationError(
-        "double_conversion_error",
-        "double() type error: cannot convert to double"
-      );
-    }
-  });
-  functionOverload("uint(number): number", (v) => Decimal.from(v));
-  functionOverload("uint(string): number", (v) => {
-    const s = v;
-    if (s !== s.trim() || s.length > 20 || s.includes("0x")) {
-      throw evaluationError("uint_conversion_error", "uint() type error: cannot convert to uint");
-    }
-    try {
-      return Decimal.from(s);
-    } catch {
-      throw evaluationError("uint_conversion_error", "uint() type error: cannot convert to uint");
-    }
-  });
   functionOverload("string(string): string", identity);
   functionOverload("string(bool): string", (v) => `${v}`);
   functionOverload("string(number): string", (v) => Decimal.from(v).toString());
@@ -284,23 +237,55 @@ export function registerFunctions(registry) {
     return new TZDate(result.getTime(), source.timeZone);
   }
   registry.registerType("Date", TZDate);
-  functionOverload("date(string): Date", (v) => {
-    const d = new TZDate(v);
+  const singularUnit = (unit) => unit.replace(/s$/, "");
+  function pickUnit(table, unit, method) {
+    const fn = table[singularUnit(unit)];
+    if (fn) return fn;
+    throw evaluationError("invalid_unit", `${method}(): unknown unit "${unit}" (expected ${objKeys(table).join(" / ")})`);
+  }
+  function checkTimeZone(tz) {
+    try {
+      new Intl.DateTimeFormat("en-US", { timeZone: tz });
+      return tz;
+    } catch {
+      throw evaluationError("invalid_timezone", `Unknown time zone "${tz}" (expected an IANA name like "Asia/Shanghai" or an offset like "+08:00")`);
+    }
+  }
+  const WALL_CLOCK_STRING = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?$/;
+  function dateFromString(v, tz) {
+    const s = v;
+    let d;
+    const m = tz === void 0 ? null : WALL_CLOCK_STRING.exec(s);
+    if (tz === void 0) {
+      d = new TZDate(s);
+    } else if (m) {
+      const ms = +(m[7] ?? "0").padEnd(3, "0").slice(0, 3);
+      d = new TZDate(+m[1], +m[2] - 1, +m[3], +(m[4] ?? "0"), +(m[5] ?? "0"), +(m[6] ?? "0"), ms, tz);
+    } else {
+      d = new TZDate(s, tz);
+    }
     if (Number.isNaN(d.getTime())) throw evaluationError("invalid_date", `date() requires a valid date string, got "${v}"`);
     return d;
-  });
-  functionOverload("date(number): Date", (v) => {
+  }
+  function dateFromTimestamp(v, tz) {
     const n = toNum(v);
     if (!Number.isFinite(n)) {
       throw evaluationError("invalid_date", `date() requires a finite timestamp, got ${v}`);
     }
     const ms = Math.abs(n) < 1e11 ? n * 1e3 : n;
-    const d = new TZDate(ms);
+    const d = tz === void 0 ? new TZDate(ms) : new TZDate(ms, tz);
     if (Number.isNaN(d.getTime())) {
       throw evaluationError("invalid_date", `date() got an out-of-range timestamp: ${v}`);
     }
     return d;
-  });
+  }
+  functionOverload("date(string): Date", (v) => dateFromString(v));
+  functionOverload("date(number): Date", (v) => dateFromTimestamp(v));
+  functionOverload("date(string, string): Date", (v, tz) => dateFromString(v, checkTimeZone(tz)));
+  functionOverload("date(number, string): Date", (v, tz) => dateFromTimestamp(v, checkTimeZone(tz)));
+  functionOverload("Date.tz(string): Date", (d, tz) => new TZDate(d.getTime(), checkTimeZone(tz)));
+  functionOverload("number(Date): number", (v) => Decimal.from(v.getTime()));
+  functionOverload("string(Date): string", (v) => v.toISOString());
   const RANGE_LIMIT = 1e5;
   function numericRange(startD, endD, stepD) {
     const step = stepD.toNumber();
@@ -324,18 +309,17 @@ export function registerFunctions(registry) {
   functionOverload("range(number, number): list<dyn>", (start, end) => numericRange(start, end, Decimal.from(1)));
   functionOverload("range(number, number, number): list<dyn>", (start, end, step) => numericRange(start, end, step));
   const rangeSteppers = {
-    year: addYears,
-    month: addMonths,
-    day: addDays,
+    second: addSeconds,
+    minute: addMinutes,
     hour: addHours,
-    minute: addMinutes
+    day: addDays,
+    week: addWeeks,
+    month: addMonths,
+    year: addYears
   };
   functionOverload("range(Date, Date, string): list<dyn>", (startV, endV, unitV) => {
     const start = startV;
-    const stepFn = rangeSteppers[unitV];
-    if (!stepFn) {
-      throw evaluationError("invalid_unit", `range(): unknown unit "${unitV}" (expected year / month / day / hour / minute)`);
-    }
+    const stepFn = pickUnit(rangeSteppers, unitV, "range");
     const endMs = endV.getTime();
     const ascending = start.getTime() < endMs;
     const out = [];
@@ -349,90 +333,79 @@ export function registerFunctions(registry) {
     }
     return out;
   });
+  const startOfFns = {
+    minute: startOfMinute,
+    hour: startOfHour,
+    day: startOfDay,
+    week: startOfWeek,
+    month: startOfMonth,
+    year: startOfYear
+  };
+  const endOfFns = {
+    minute: endOfMinute,
+    hour: endOfHour,
+    day: endOfDay,
+    week: endOfWeek,
+    month: endOfMonth,
+    year: endOfYear
+  };
+  const offsetFns = {
+    millisecond: addMilliseconds,
+    second: addSeconds,
+    minute: addMinutes,
+    hour: addHours,
+    day: addDays,
+    week: addWeeks,
+    month: addMonths,
+    year: addYears
+  };
+  const setFns = {
+    millisecond: setMilliseconds,
+    second: setSeconds,
+    minute: setMinutes,
+    hour: setHours,
+    day: setDayOfMonth,
+    month: (d, v) => setMonth(d, v - 1),
+    year: setYear
+  };
+  const diffFns = {
+    millisecond: differenceInMilliseconds,
+    second: differenceInSeconds,
+    minute: differenceInMinutes,
+    hour: differenceInHours,
+    day: differenceInDays,
+    week: differenceInWeeks,
+    month: differenceInMonths,
+    year: differenceInYears
+  };
+  const getFns = {
+    millisecond: (d) => d.getMilliseconds(),
+    second: (d) => d.getSeconds(),
+    minute: (d) => d.getMinutes(),
+    hour: (d) => d.getHours(),
+    day: (d) => d.getDate(),
+    weekday: (d) => (d.getDay() + 6) % 7 + 1,
+    month: (d) => d.getMonth() + 1,
+    year: (d) => d.getFullYear()
+  };
   functionOverload("Date.startOf(string): Date", (d, unit) => {
     const date = d;
-    switch (unit) {
-      case "day":
-        return wrapTZ(startOfDay(date), date);
-      case "week":
-        return wrapTZ(startOfWeek(date), date);
-      case "month":
-        return wrapTZ(startOfMonth(date), date);
-      case "year":
-        return wrapTZ(startOfYear(date), date);
-      default:
-        throw evaluationError("invalid_unit", `startOf(): unknown unit "${unit}"`);
-    }
+    return wrapTZ(pickUnit(startOfFns, unit, "startOf")(date), date);
   });
   functionOverload("Date.endOf(string): Date", (d, unit) => {
     const date = d;
-    switch (unit) {
-      case "day":
-        return wrapTZ(endOfDay(date), date);
-      case "week":
-        return wrapTZ(endOfWeek(date), date);
-      case "month":
-        return wrapTZ(endOfMonth(date), date);
-      case "year":
-        return wrapTZ(endOfYear(date), date);
-      default:
-        throw evaluationError("invalid_unit", `endOf(): unknown unit "${unit}"`);
-    }
+    return wrapTZ(pickUnit(endOfFns, unit, "endOf")(date), date);
   });
   functionOverload("Date.offset(number, string): Date", (d, n, unit) => {
     const date = d;
-    const num = toNum(n);
-    switch (unit.replace(/s$/, "")) {
-      case "day":
-        return wrapTZ(addDays(date, num), date);
-      case "week":
-        return wrapTZ(addWeeks(date, num), date);
-      case "month":
-        return wrapTZ(addMonths(date, num), date);
-      case "year":
-        return wrapTZ(addYears(date, num), date);
-      default:
-        throw evaluationError("invalid_unit", `offset(): unknown unit "${unit}"`);
-    }
-  });
-  functionOverload("Date.diff(Date, string): number", (d, other, unit) => {
-    const left = d;
-    const right = other;
-    switch (unit.replace(/s$/, "")) {
-      case "millisecond":
-        return Decimal.from(differenceInMilliseconds(left, right));
-      case "second":
-        return Decimal.from(differenceInSeconds(left, right));
-      case "minute":
-        return Decimal.from(differenceInMinutes(left, right));
-      case "hour":
-        return Decimal.from(differenceInHours(left, right));
-      case "day":
-        return Decimal.from(differenceInDays(left, right));
-      case "week":
-        return Decimal.from(differenceInWeeks(left, right));
-      case "month":
-        return Decimal.from(differenceInMonths(left, right));
-      case "year":
-        return Decimal.from(differenceInYears(left, right));
-      default:
-        throw evaluationError("invalid_unit", `diff(): unknown unit "${unit}"`);
-    }
+    return wrapTZ(pickUnit(offsetFns, unit, "offset")(date, toNum(n)), date);
   });
+  functionOverload("Date.diff(Date, string): number", (d, other, unit) => Decimal.from(pickUnit(diffFns, unit, "diff")(d, other)));
   functionOverload("Date.set(string, number): Date", (d, field, value) => {
     const date = d;
-    const val = toNum(value);
-    switch (field) {
-      case "day":
-        return wrapTZ(setDayOfMonth(date, val), date);
-      case "month":
-        return wrapTZ(setMonth(date, val - 1), date);
-      case "year":
-        return wrapTZ(setYear(date, val), date);
-      default:
-        throw evaluationError("invalid_field", `set(): unknown field "${field}"`);
-    }
+    return wrapTZ(pickUnit(setFns, field, "set")(date, toNum(value)), date);
   });
+  functionOverload("Date.get(string): number", (d, field) => Decimal.from(pickUnit(getFns, field, "get")(d)));
   functionOverload("Date.format(string): string", (d, fmt) => formatDate(d, fmt));
   registry.registerType("File", File);
   registry.registerType("URL", URL);