@shwfed/config 1.0.0

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

@@ -0,0 +1,112 @@
+export class CelError extends Error {
+  #node;
+  #code;
+  #range;
+  #summary;
+  constructor({ name, code, message, node, cause, range }) {
+    super(message, cause ? { cause } : void 0);
+    this.name = name;
+    this.#code = code;
+    this.#summary = message;
+    this.#node = node;
+    this.#range = range && normalizeRange(range) || normalizeRange(node);
+    if (!node?.input) return;
+    this.message = formatErrorWithHighlight(this.#summary, node, this.#range);
+  }
+  get node() {
+    return this.#node;
+  }
+  get code() {
+    return this.#code;
+  }
+  get range() {
+    return this.#range;
+  }
+  get summary() {
+    return this.#summary;
+  }
+  withAst(node) {
+    if (this.#node || !node?.input) return this;
+    this.#node = node;
+    this.#range ??= normalizeRange(node);
+    this.message = formatErrorWithHighlight(this.#summary, node, this.#range);
+    return this;
+  }
+}
+function normalizeArgs(name, defaultCode, message, node, cause) {
+  if (typeof message === "string") return { name, code: defaultCode, message, node, cause };
+  const opts = message;
+  if (typeof opts !== "object") throw new Error("First param to error must be a string or object");
+  return {
+    name,
+    code: opts.code || defaultCode,
+    message: opts.message,
+    node: opts.node,
+    cause: opts.cause,
+    range: opts.range
+  };
+}
+export class ParseError extends CelError {
+  constructor(message, node, cause) {
+    super(normalizeArgs("ParseError", "parse_error", message, node, cause));
+  }
+}
+export class EvaluationError extends CelError {
+  constructor(message, node, cause) {
+    super(normalizeArgs("EvaluationError", "evaluation_error", message, node, cause));
+  }
+}
+export class TypeError extends CelError {
+  constructor(message, node, cause) {
+    super(normalizeArgs("TypeError", "type_error", message, node, cause));
+  }
+}
+export function parseError(code, message, node) {
+  if (typeof code === "object") return new ParseError(code);
+  return new ParseError({ code, message, node });
+}
+export function evaluationError(code, message, node) {
+  if (typeof code === "object") return new EvaluationError(code);
+  return new EvaluationError({ code, message, node });
+}
+export function typeError(code, message, node) {
+  if (typeof code === "object") return new TypeError(code);
+  return new TypeError({ code, message, node });
+}
+function normalizeRange(node) {
+  const start = node?.pos ?? node?.start;
+  if (typeof start !== "number") return void 0;
+  const end = typeof node?.end === "number" ? node.end : start;
+  return { start, end };
+}
+function formatErrorWithHighlight(message, node, range) {
+  const pos = node.pos ?? range?.start;
+  if (typeof pos !== "number") return message;
+  const input = node.input;
+  let lineNum = 1;
+  let currentPos = 0;
+  let columnNum = 0;
+  while (currentPos < pos) {
+    if (input[currentPos] === "\n") {
+      lineNum++;
+      columnNum = 0;
+    } else {
+      columnNum++;
+    }
+    currentPos++;
+  }
+  let contextStart = pos;
+  let contextEnd = pos;
+  while (contextStart > 0 && input[contextStart - 1] !== "\n") contextStart--;
+  while (contextEnd < input.length && input[contextEnd] !== "\n") contextEnd++;
+  const line = input.slice(contextStart, contextEnd);
+  const highlight = `> ${`${lineNum}`.padStart(4, " ")} | ${line}
+${" ".repeat(9 + columnNum)}^`;
+  return `${message}
+
+${highlight}`;
+}
+export function attachErrorAst(error, node) {
+  if (error instanceof CelError) return error.withAst(node);
+  return error;
+}

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

@@ -0,0 +1,37 @@
+import { Either, Effect } from 'effect';
+import type { Registry } from './registry.js.js';
+import type { ParseError, EvaluationError, TypeError } from './errors.js.js';
+import type { ASTNode } from './parser.js.js';
+import type { Limits } from './options.js.js';
+interface ParsedExpression {
+    (context?: Record<string, unknown>): Effect.Effect<unknown, unknown>;
+    check: () => {
+        valid: boolean;
+        type?: string;
+        error?: unknown;
+    };
+    ast: ASTNode;
+}
+declare class Environment {
+    #private;
+    constructor(opts?: {
+        unlistedVariablesAreDyn?: boolean;
+        limits?: Partial<Limits>;
+    } | null, inherited?: Environment);
+    clone(opts?: {
+        unlistedVariablesAreDyn?: boolean;
+        limits?: Partial<Limits>;
+    } | null): Environment;
+    registerFunction(signature: string, handler?: (...args: unknown[]) => unknown, opts?: unknown): this;
+    registerOperator(signature: string, handler?: (...args: unknown[]) => unknown, opts?: unknown): this;
+    registerType(typename: string, constructor: unknown): this;
+    registerVariable(name: string, type?: unknown, opts?: unknown): this;
+    registerConstant(name: string, type: unknown, value: unknown): this;
+    getDefinitions(): ReturnType<Registry['getDefinitions']>;
+    check(expression: string): Either.Either<string, ParseError | TypeError>;
+    parse(expression: string): ParsedExpression;
+    evaluate<T>(expression: string, context?: Record<string, unknown>): Effect.Effect<T, ParseError | TypeError | EvaluationError>;
+}
+export declare function parse(expression: string): ParsedExpression;
+export declare function evaluate<T>(expression: string, context?: Record<string, unknown>): Effect.Effect<T, ParseError | TypeError | EvaluationError>;
+export { Environment };

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

@@ -0,0 +1,163 @@
+import { Either, Effect } from "effect";
+import { createRegistry, RootContext } from "./registry.js";
+import { evaluationError } from "./errors.js";
+import { registerFunctions } from "./functions.js";
+import { registerHttpBuiltins } from "./http-builtins.js";
+import { registerMacros } from "./macros.js";
+import { registerOverloads } from "./overloads.js";
+import { TypeChecker } from "./type-checker.js";
+import { Parser } from "./parser.js";
+import { createOptions } from "./options.js";
+import { Base } from "./operators.js";
+const globalRegistry = createRegistry();
+registerFunctions(globalRegistry);
+registerOverloads(globalRegistry);
+registerMacros(globalRegistry);
+registerHttpBuiltins(globalRegistry);
+class Environment {
+  #registry;
+  #evaluator;
+  #typeChecker;
+  #evalTypeChecker;
+  #parser;
+  #opts;
+  constructor(opts, inherited) {
+    this.#opts = createOptions(opts, inherited instanceof Environment ? inherited.#opts : void 0);
+    this.#registry = (inherited instanceof Environment ? inherited.#registry : globalRegistry).clone(this.#opts);
+    const childOpts = { registry: this.#registry, opts: this.#opts };
+    this.#typeChecker = new TypeChecker(childOpts);
+    this.#evalTypeChecker = new TypeChecker(childOpts, true);
+    this.#evaluator = new Evaluator(childOpts);
+    this.#parser = new Parser(this.#opts.limits, this.#registry);
+    Object.freeze(this);
+  }
+  clone(opts) {
+    return new Environment(opts, this);
+  }
+  registerFunction(signature, handler, opts) {
+    this.#registry.registerFunctionOverload(signature, handler, opts);
+    return this;
+  }
+  registerOperator(signature, handler, opts) {
+    this.#registry.registerOperatorOverload(signature, handler, opts);
+    return this;
+  }
+  registerType(typename, constructor) {
+    this.#registry.registerType(typename, constructor);
+    return this;
+  }
+  registerVariable(name, type, opts) {
+    this.#registry.registerVariable(name, type, opts);
+    return this;
+  }
+  registerConstant(name, type, value) {
+    this.#registry.registerConstant(name, type, value);
+    return this;
+  }
+  getDefinitions() {
+    return this.#registry.getDefinitions();
+  }
+  check(expression) {
+    try {
+      const ast = this.#parser.parse(expression);
+      const typeDecl = this.#typeChecker.check(ast, new RootContext(this.#registry));
+      return Either.right(this.#formatTypeForCheck(typeDecl));
+    } catch (error) {
+      return Either.left(error);
+    }
+  }
+  #formatTypeForCheck(typeDecl) {
+    if (typeDecl.name === `list<dyn>`) return "list";
+    if (typeDecl.name === `map<dyn, dyn>`) return "map";
+    return typeDecl.name;
+  }
+  parse(expression) {
+    const ast = this.#parser.parse(expression);
+    const evaluateFn = this.#evaluateAST.bind(this, ast);
+    evaluateFn.check = () => {
+      try {
+        const typeDecl = this.#typeChecker.check(ast, new RootContext(this.#registry));
+        return { valid: true, type: this.#formatTypeForCheck(typeDecl) };
+      } catch (error) {
+        return { valid: false, error };
+      }
+    };
+    evaluateFn.ast = ast;
+    return evaluateFn;
+  }
+  evaluate(expression, context) {
+    return Effect.try({
+      try: () => {
+        const ast = this.#parser.parse(expression);
+        const ctx = new RootContext(this.#registry, context);
+        if (!ast.checkedType) this.#evalTypeChecker.check(ast, ctx);
+        return { ast, ctx };
+      },
+      catch: (error) => error
+    }).pipe(
+      Effect.flatMap(({ ast, ctx }) => ast.evaluate(this.#evaluator, ast, ctx))
+    );
+  }
+  #evaluateAST(ast, context) {
+    return Effect.try({
+      try: () => {
+        const ctx = new RootContext(this.#registry, context);
+        if (!ast.checkedType) this.#evalTypeChecker.check(ast, ctx);
+        return ctx;
+      },
+      catch: (error) => error
+    }).pipe(
+      Effect.flatMap((ctx) => ast.evaluate(this.#evaluator, ast, ctx))
+    );
+  }
+}
+class Evaluator extends Base {
+  constructor(opts) {
+    super(opts);
+    this.createError = evaluationError;
+  }
+  #firstMapElement(coll) {
+    if (coll instanceof Map) return coll.entries().next().value;
+    for (const key in coll) return [key, coll[key]];
+    return void 0;
+  }
+  debugRuntimeType(value, checkedType) {
+    return checkedType?.hasDynType === false ? checkedType : this.debugTypeDeep(value);
+  }
+  debugTypeDeep(value) {
+    const runtimeType = this.debugType(value);
+    switch (runtimeType.kind) {
+      case "list": {
+        const first = value instanceof Array ? value[0] : value.values().next().value;
+        if (first === void 0) return runtimeType;
+        return this.registry.getListType(this.debugTypeDeep(first));
+      }
+      case "map": {
+        const first = this.#firstMapElement(value);
+        if (!first) return runtimeType;
+        return this.registry.getMapType(
+          runtimeType.keyType.hasDynType ? this.debugTypeDeep(first[0]) : runtimeType.keyType,
+          runtimeType.valueType.hasDynType ? this.debugTypeDeep(first[1]) : runtimeType.valueType
+        );
+      }
+      default:
+        return runtimeType;
+    }
+  }
+  tryEval(ast, ctx) {
+    return Effect.either(this.eval(ast, ctx));
+  }
+  eval(ast, ctx) {
+    return ast.evaluate(this, ast, ctx);
+  }
+}
+const globalEnvironment = new Environment({
+  unlistedVariablesAreDyn: true
+});
+export function parse(expression) {
+  return globalEnvironment.parse(expression);
+}
+export function evaluate(expression, context) {
+  return globalEnvironment.evaluate(expression, context);
+}
+export { Environment };

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

@@ -0,0 +1,2 @@
+import type { Registry } from './registry.js.js';
+export declare function registerFunctions(registry: Registry): void;

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

@@ -0,0 +1,340 @@
+import { evaluationError } from "./errors.js";
+import { Decimal } from "./decimal.js";
+import { TYPES, Type } from "./registry.js";
+import { register as registerOptional } 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, setDate as setDayOfMonth, setMonth, setYear, format as formatDate } from "date-fns";
+function toNum(v) {
+  if (v instanceof Decimal) return v.toNumber();
+  if (typeof v === "bigint") return Number(v);
+  return v;
+}
+export function registerFunctions(registry) {
+  const sync = { async: false };
+  const functionOverload = (sig, handler) => registry.registerFunctionOverload(sig, handler, sync);
+  const identity = (v) => v;
+  functionOverload("dyn(dyn): dyn", identity);
+  for (const _t in TYPES) {
+    const type = TYPES[_t];
+    if (!(type instanceof Type)) continue;
+    functionOverload(`type(${type.name}): type`, () => type);
+  }
+  functionOverload("bool(bool): bool", identity);
+  functionOverload("bool(string): bool", (v) => {
+    switch (v) {
+      case "1":
+      case "t":
+      case "true":
+      case "TRUE":
+      case "True":
+        return true;
+      case "0":
+      case "f":
+      case "false":
+      case "FALSE":
+      case "False":
+        return false;
+      default:
+        throw evaluationError(
+          "bool_conversion_error",
+          `bool() conversion error: invalid string value "${v}"`
+        );
+    }
+  });
+  functionOverload("size(string): number", (v) => Decimal.from(stringSize(v)));
+  functionOverload("size(bytes): number", (v) => Decimal.from(v.length));
+  functionOverload("size(list): number", (v) => Decimal.from(v.length ?? v.size));
+  functionOverload("size(map): number", (v) => Decimal.from(v instanceof Map ? v.size : objKeys(v).length));
+  functionOverload("string.size(): number", (v) => Decimal.from(stringSize(v)));
+  functionOverload("bytes.size(): number", (v) => Decimal.from(v.length));
+  functionOverload("list.size(): number", (v) => Decimal.from(v.length ?? v.size));
+  functionOverload("map.size(): number", (v) => Decimal.from(v instanceof Map ? v.size : objKeys(v).length));
+  functionOverload("bytes(string): bytes", (v) => ByteOpts.fromString(v));
+  functionOverload("bytes(bytes): bytes", identity);
+  functionOverload("number(number): number", (v) => Decimal.from(v));
+  functionOverload("number(string): number", (v) => {
+    const s = v;
+    if (!s || s !== s.trim())
+      throw evaluationError(
+        "number_conversion_error",
+        "number() type error: cannot convert to number"
+      );
+    try {
+      return Decimal.from(s);
+    } catch {
+      throw evaluationError(
+        "number_conversion_error",
+        "number() type error: cannot convert to number"
+      );
+    }
+  });
+  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());
+  functionOverload("string(bytes): string", (v) => ByteOpts.toUtf8(v));
+  functionOverload("string.startsWith(string): bool", (a, b) => a.startsWith(b));
+  functionOverload("string.endsWith(string): bool", (a, b) => a.endsWith(b));
+  functionOverload("string.contains(string): bool", (a, b) => a.includes(b));
+  functionOverload("string.lowerAscii(): string", (a) => a.toLowerCase());
+  functionOverload("string.upperAscii(): string", (a) => a.toUpperCase());
+  functionOverload("string.trim(): string", (a) => a.trim());
+  functionOverload(
+    "string.indexOf(string): number",
+    (string, search) => Decimal.from(string.indexOf(search))
+  );
+  functionOverload("string.indexOf(string, number): number", (string, search, fromIndex) => {
+    if (search === "") return fromIndex;
+    const from = toNum(fromIndex);
+    const str = string;
+    if (from < 0 || from >= str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.indexOf(search, fromIndex): fromIndex out of range"
+      );
+    }
+    return Decimal.from(str.indexOf(search, from));
+  });
+  functionOverload(
+    "string.lastIndexOf(string): number",
+    (string, search) => Decimal.from(string.lastIndexOf(search))
+  );
+  functionOverload("string.lastIndexOf(string, number): number", (string, search, fromIndex) => {
+    if (search === "") return fromIndex;
+    const from = toNum(fromIndex);
+    const str = string;
+    if (from < 0 || from >= str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.lastIndexOf(search, fromIndex): fromIndex out of range"
+      );
+    }
+    return Decimal.from(str.lastIndexOf(search, from));
+  });
+  functionOverload("string.substring(number): string", (string, start) => {
+    const startNum = toNum(start);
+    const str = string;
+    if (startNum < 0 || startNum > str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.substring(start, end): start index out of range"
+      );
+    }
+    return str.substring(startNum);
+  });
+  functionOverload("string.substring(number, number): string", (string, start, end) => {
+    const startNum = toNum(start);
+    const str = string;
+    if (startNum < 0 || startNum > str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.substring(start, end): start index out of range"
+      );
+    }
+    const endNum = toNum(end);
+    if (endNum < startNum || endNum > str.length) {
+      throw evaluationError(
+        "index_out_of_range",
+        "string.substring(start, end): end index out of range"
+      );
+    }
+    return str.substring(startNum, endNum);
+  });
+  functionOverload("string.matches(string): bool", (a, b) => {
+    try {
+      return new RegExp(b).test(a);
+    } catch {
+      throw evaluationError("invalid_regular_expression", `Invalid regular expression: ${b}`);
+    }
+  });
+  functionOverload("string.split(string): list<string>", (s, sep) => s.split(sep));
+  functionOverload("string.split(string, number): list<string>", (s, sep, l) => {
+    const limit = toNum(l);
+    if (limit === 0) return [];
+    const parts = s.split(sep);
+    if (limit < 0 || parts.length <= limit) return parts;
+    const limited = parts.slice(0, limit - 1);
+    limited.push(parts.slice(limit - 1).join(sep));
+    return limited;
+  });
+  functionOverload("list<string>.join(): string", (v) => {
+    const arr = v;
+    for (let i = 0; i < arr.length; i++) {
+      if (typeof arr[i] !== "string") {
+        throw evaluationError(
+          "invalid_list_element_type",
+          "string.join(): list must contain only strings"
+        );
+      }
+    }
+    return arr.join("");
+  });
+  functionOverload("list<string>.join(string): string", (v, sep) => {
+    const arr = v;
+    for (let i = 0; i < arr.length; i++) {
+      if (typeof arr[i] !== "string") {
+        throw evaluationError(
+          "invalid_list_element_type",
+          "string.join(separator): list must contain only strings"
+        );
+      }
+    }
+    return arr.join(sep);
+  });
+  const textEncoder = new TextEncoder();
+  const textDecoder = new TextDecoder("utf8");
+  const ByteOpts = typeof Buffer !== "undefined" ? {
+    byteLength: (v) => Buffer.byteLength(v),
+    fromString: (str) => Buffer.from(str, "utf8"),
+    toHex: (b) => Buffer.prototype.hexSlice.call(b, 0, b.length),
+    toBase64: (b) => Buffer.prototype.base64Slice.call(b, 0, b.length),
+    toUtf8: (b) => Buffer.prototype.utf8Slice.call(b, 0, b.length),
+    jsonParse: (b) => JSON.parse(b)
+  } : {
+    textEncoder: new TextEncoder(),
+    byteLength: (v) => textEncoder.encode(v).length,
+    fromString: (str) => textEncoder.encode(str),
+    toHex: typeof Uint8Array.prototype.toHex === "function" ? (b) => b.toHex() : (b) => arrayFrom(b, (i) => i.toString(16).padStart(2, "0")).join(""),
+    toBase64: typeof Uint8Array.prototype.toBase64 === "function" ? (b) => b.toBase64() : (b) => btoa(arrayFrom(b, (i) => String.fromCodePoint(i)).join("")),
+    toUtf8: (b) => textDecoder.decode(b),
+    jsonParse: (b) => JSON.parse(textDecoder.decode(b))
+  };
+  functionOverload("bytes.json(): map", ByteOpts.jsonParse);
+  functionOverload("bytes.hex(): string", ByteOpts.toHex);
+  functionOverload("bytes.string(): string", ByteOpts.toUtf8);
+  functionOverload("bytes.base64(): string", ByteOpts.toBase64);
+  functionOverload("bytes.at(number): number", (b, index) => {
+    const idx = toNum(index);
+    const buf = b;
+    if (idx < 0 || idx >= buf.length) {
+      throw evaluationError("index_out_of_range", "Bytes index out of range");
+    }
+    return Decimal.from(buf[idx]);
+  });
+  function wrapTZ(result, source) {
+    if (result instanceof TZDate) return result;
+    return new TZDate(result.getTime(), source.timeZone);
+  }
+  registry.registerType("Date", TZDate);
+  functionOverload("date(string): Date", (v) => {
+    const d = new TZDate(v);
+    if (Number.isNaN(d.getTime())) throw evaluationError("invalid_date", `date() requires a valid date string, got "${v}"`);
+    return d;
+  });
+  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}"`);
+    }
+  });
+  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}"`);
+    }
+  });
+  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.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}"`);
+    }
+  });
+  functionOverload("Date.format(string): string", (d, fmt) => formatDate(d, fmt));
+  registry.registerType("File", File);
+  registerOptional(registry);
+}
+function stringSize(str) {
+  let count = 0;
+  for (const _ of str) count++;
+  return count;
+}

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

@@ -0,0 +1,27 @@
+export declare const hasOwn: (o: object, v: PropertyKey) => boolean;
+export declare const objKeys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+export declare const objFreeze: {
+    <T extends Function>(f: T): T;
+    <T extends {
+        [idx: string]: U | null | undefined | object;
+    }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
+    <T>(o: T): Readonly<T>;
+};
+export declare const objEntries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+export declare const isArray: (arg: any) => arg is any[];
+export declare const arrayFrom: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+    <T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+    <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+};
+export declare function isAsync(fn: Function | undefined | null, fallback?: boolean): boolean;
+export declare const RESERVED: Set<string>;