@shwfed/config 1.1.4 → 2.0.0

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

@@ -1,673 +0,0 @@
-import { Effect, Either, Option } from "effect";
-import { celTypes } from "./registry.js";
-import { Decimal } from "./decimal.js";
-import { objKeys, isArray, hasOwn } from "./globals.js";
-import { attachErrorAst } from "./errors.js";
-const dynType = celTypes.dyn;
-export class Base {
-  dynType = celTypes.dyn;
-  optionalType = celTypes.optional;
-  stringType = celTypes.string;
-  numberType = celTypes.number;
-  boolType = celTypes.bool;
-  nullType = celTypes.null;
-  listType = celTypes.list;
-  mapType = celTypes.map;
-  opts;
-  registry;
-  objectTypes;
-  objectTypesByConstructor;
-  constructor(opts) {
-    this.opts = opts.opts;
-    this.registry = opts.registry;
-    this.objectTypes = this.registry.objectTypes;
-    this.objectTypesByConstructor = this.registry.objectTypesByConstructor;
-  }
-  getType(typeName) {
-    return this.registry.getType(typeName);
-  }
-  debugType(v) {
-    switch (typeof v) {
-      case "string":
-        return this.stringType;
-      case "number":
-      case "bigint":
-        return this.numberType;
-      case "boolean":
-        return this.boolType;
-      case "object":
-        if (v === null) return this.nullType;
-        if (v instanceof Decimal) return this.numberType;
-        if (Option.isOption(v)) return this.optionalType;
-        switch (v.constructor) {
-          case void 0:
-          case Object:
-          case Map:
-            return this.mapType;
-          case Array:
-          case Set:
-            return this.listType;
-          default:
-            return this.objectTypesByConstructor.get(v.constructor)?.type || unsupportedType(this, v.constructor?.name || typeof v);
-        }
-      default:
-        unsupportedType(this, typeof v);
-    }
-  }
-}
-function unsupportedType(self, type) {
-  throw self.createError("unsupported_type", `Unsupported type: ${type}`);
-}
-function checkAccessNode(chk, ast, ctx) {
-  ast.right = ast.args[1];
-  const leftType = chk.check(ast.left = ast.args[0], ctx);
-  if (ast.op === "[]") chk.check(ast.right, ctx);
-  ast.handle = leftType !== dynType ? fieldAccessStatic : fieldAccess;
-  if (leftType.kind !== "optional") return chk.checkAccessOnType(ast, ctx, leftType);
-  return chk.registry.getOptionalType(chk.checkAccessOnType(ast, ctx, leftType.valueType, true));
-}
-function checkOptionalAccessNode(chk, ast, ctx) {
-  ast.right = ast.args[1];
-  const leftType = chk.check(ast.left = ast.args[0], ctx);
-  if (ast.op === "[?]") chk.check(ast.right, ctx);
-  ast.handle = oFieldAccess;
-  const actualType = leftType.kind === "optional" ? leftType.valueType : leftType;
-  return chk.registry.getOptionalType(chk.checkAccessOnType(ast, ctx, actualType, true));
-}
-function checkElement(chk, ctx, expected, el) {
-  return expected.unify(chk.registry, chk.check(el, ctx)) ?? dynType;
-}
-function ternaryConditionError(ev, value, node) {
-  const type = ev.debugRuntimeType(value);
-  return ev.createError(
-    "invalid_condition_type",
-    `${node.meta.label || "Ternary condition must be bool"}, got '${type}'`,
-    node
-  );
-}
-function handleTernary(c, ev, ast, ctx) {
-  if (c === true) return ev.eval(ast.left, ctx);
-  if (c === false) return ev.eval(ast.right, ctx);
-  return Effect.fail(ternaryConditionError(ev, c, ast.condition));
-}
-function logicalOperandError(ev, value, node) {
-  const type = ev.debugRuntimeType(value);
-  return ev.createError(
-    "invalid_logical_operand",
-    `Logical operator requires bool operands, got '${type}'`,
-    node
-  );
-}
-function checkLogicalOp(chk, ast, ctx) {
-  const leftType = chk.check(ast.left = ast.args[0], ctx);
-  const rightType = chk.check(ast.right = ast.args[1], ctx);
-  if (!leftType.isDynOrBool()) {
-    throw chk.createError(
-      "invalid_logical_operand",
-      `Logical operator requires bool operands, got '${chk.formatType(leftType)}'`,
-      ast
-    );
-  }
-  if (!rightType.isDynOrBool()) {
-    throw chk.createError(
-      "invalid_logical_operand",
-      `Logical operator requires bool operands, got '${chk.formatType(rightType)}'`,
-      ast
-    );
-  }
-  return chk.boolType;
-}
-function checkUnary(chk, ast, ctx) {
-  const op = ast.op;
-  const right = chk.check(ast.args, ctx);
-  ast.candidates = chk.registry.operatorCandidates(op);
-  if (right.kind === "dyn") {
-    ast.handle = handleUnary;
-    return ast.candidates.returnType;
-  }
-  const overload = ast.candidates.findUnaryOverload(right);
-  if (!overload) {
-    throw chk.createError(
-      "no_such_overload",
-      `no such overload: ${op[0]}${chk.formatType(right)}`,
-      ast
-    );
-  }
-  ast.handle = overload.handler;
-  return overload.returnType;
-}
-function handleUnary(left, ast, ev) {
-  const a = ast;
-  const e = ev;
-  const leftType = e.debugRuntimeType(left, a.args.checkedType);
-  const overload = a.candidates.findUnaryOverload(leftType);
-  if (overload) return overload.handler(left);
-  throw e.createError("no_such_overload", `no such overload: ${a.op[0]}${leftType}`, a);
-}
-function evaluateUnary(ev, ast, ctx) {
-  return ev.eval(ast.args, ctx).pipe(
-    Effect.flatMap(
-      (val) => Effect.try({
-        try: () => ast.handle(val, ast, ev),
-        catch: (e) => e
-      })
-    )
-  );
-}
-function checkBinary(chk, ast, ctx) {
-  const op = ast.op;
-  const left = chk.check(ast.left = ast.args[0], ctx);
-  const right = chk.check(ast.right = ast.args[1], ctx);
-  ast.candidates = chk.registry.operatorCandidates(op);
-  const overload = left.hasDynType || right.hasDynType ? void 0 : ast.candidates.findBinaryOverload(left, right);
-  ast.handle = overload ? overload.handler : handleBinary;
-  if (overload) return overload.returnType;
-  const type = ast.candidates.checkBinaryOverload(left, right);
-  if (!left.hasDynType) ast.leftStaticType = left;
-  if (!right.hasDynType) ast.rightStaticType = right;
-  if (type) return type;
-  throw chk.createError(
-    "no_such_overload",
-    `no such overload: ${chk.formatType(left)} ${op} ${chk.formatType(right)}`,
-    ast
-  );
-}
-function evaluateBinary(ev, ast, ctx) {
-  return Effect.all([ev.eval(ast.left, ctx), ev.eval(ast.right, ctx)]).pipe(
-    Effect.flatMap(
-      ([l, r]) => Effect.try({
-        try: () => ast.handle(l, r, ast, ev),
-        catch: (e) => e
-      })
-    )
-  );
-}
-function evaluateBinaryFirst(ev, ast, ctx) {
-  return ev.eval(ast.left, ctx).pipe(
-    Effect.flatMap(
-      (l) => Effect.try({
-        try: () => ast.handle(l, ast.right, ast, ev),
-        catch: (e) => e
-      })
-    )
-  );
-}
-function handleBinary(left, right, ast, ev) {
-  const a = ast;
-  const e = ev;
-  const leftType = a.leftStaticType || e.debugTypeDeep(left).wrappedType;
-  const rightType = a.rightStaticType || e.debugTypeDeep(right).wrappedType;
-  const overload = a.candidates.findBinaryOverload(leftType, rightType);
-  if (overload) return overload.handler(left, right, ast, ev);
-  throw e.createError(
-    "no_such_overload",
-    `no such overload: ${leftType} ${a.op} ${rightType}`,
-    a
-  );
-}
-function callFunctionHandler(handler, ev, args, ast) {
-  return Effect.try({
-    try: () => handler.apply(ev, args),
-    catch: (error) => attachErrorAst(error, ast)
-  }).pipe(
-    Effect.flatMap(
-      (result) => Effect.isEffect(result) && !Option.isOption(result) ? result.pipe(Effect.mapError((error) => attachErrorAst(error, ast))) : Effect.succeed(result)
-    )
-  );
-}
-function callFn(args, ast, ev) {
-  const a = ast;
-  const e = ev;
-  const argArr = args;
-  const argAst = a.args[1];
-  const types = a.argTypes;
-  let i = argAst.length;
-  while (i--) types[i] = e.debugRuntimeType(argArr[i], argAst[i].checkedType);
-  const decl = a.candidates.findFunction(types);
-  if (decl) return callFunctionHandler(decl.handler, e, argArr, a);
-  return Effect.fail(
-    e.createError(
-      "no_matching_overload",
-      `found no matching overload for '${a.args[0]}(${types.map((t) => t.unwrappedType).join(", ")})'`,
-      a
-    )
-  );
-}
-function callRecFn(args, ev, ast) {
-  const a = ast;
-  const e = ev;
-  const argArr = args;
-  const [, receiverAst, argAst] = a.args;
-  const types = a.argTypes;
-  for (let i = 0; i < types.length; i++)
-    types[i] = e.debugRuntimeType(argArr[i + 1], argAst[i].checkedType);
-  const receiverType = e.debugRuntimeType(argArr[0], receiverAst.checkedType);
-  const decl = a.candidates.findFunction(types, receiverType);
-  if (decl) return callFunctionHandler(decl.handler, e, argArr, a);
-  return Effect.fail(
-    e.createError(
-      "no_matching_overload",
-      `found no matching overload for '${receiverType.type}.${a.args[0]}(${types.map((t) => t.unwrappedType).join(", ")})'`,
-      a
-    )
-  );
-}
-function resolveAstArray(ev, astArray, ctx) {
-  if (astArray.length === 0) return Effect.succeed([]);
-  return Effect.all(astArray.map((a) => ev.eval(a, ctx)));
-}
-function safeFromEntries(entries) {
-  const obj = {};
-  for (let i = 0; i < entries.length; i++) {
-    const [k, v] = entries[i];
-    if (k === "__proto__" || k === "constructor" || k === "prototype") continue;
-    obj[k] = v;
-  }
-  return obj;
-}
-function comprehensionElementType(chk, iterable, ctx) {
-  const iterType = chk.check(iterable, ctx);
-  if (iterType.kind === "dyn") return iterType;
-  if (iterType.kind === "list") return iterType.valueType;
-  if (iterType.kind === "map") return iterType.keyType;
-  throw chk.createError(
-    "invalid_comprehension_range",
-    `Expression of type '${chk.formatType(
-      iterType
-    )}' cannot be range of a comprehension (must be list, map, or dynamic).`,
-    iterable
-  );
-}
-function toIterable(ev, args, coll) {
-  if (coll instanceof Set) return [...coll];
-  if (coll instanceof Map) return [...coll.keys()];
-  if (coll && typeof coll === "object") return objKeys(coll);
-  throw ev.createError(
-    "invalid_comprehension_range",
-    `Expression of type '${ev.debugType(
-      coll
-    )}' cannot be range of a comprehension (must be list, map, or dynamic).`,
-    args.iterable
-  );
-}
-function runQualifier(items, args, ev, ctx) {
-  return Effect.gen(function* () {
-    if (!isArray(items)) items = toIterable(ev, args, items);
-    let accu = yield* ev.eval(args.init, ctx = args.iterCtx.reuse(ctx));
-    ctx.accuValue = accu;
-    let error = null;
-    const condition = args.condition;
-    const step = args.step;
-    const len = items.length;
-    for (let i = 0; i < len; i++) {
-      if (!condition(accu)) return args.result(accu);
-      const stp = yield* Effect.either(ev.eval(step, ctx.setIterValue(items[i], ev)));
-      if (Either.isLeft(stp)) {
-        error ??= stp.left;
-        continue;
-      }
-      accu = stp.right;
-      ctx.accuValue = accu;
-    }
-    if (error && condition(accu)) return yield* Effect.fail(error);
-    return args.result(accu);
-  });
-}
-function runComprehension(items, args, ev, ctx) {
-  return Effect.gen(function* () {
-    if (!isArray(items)) items = toIterable(ev, args, items);
-    let accu = yield* ev.eval(args.init, ctx = args.iterCtx.reuse(ctx));
-    ctx.accuValue = accu;
-    const condition = args.condition;
-    const step = args.step;
-    const len = items.length;
-    for (let i = 0; i < len; i++) {
-      if (condition && !condition(accu)) break;
-      accu = yield* ev.eval(step, ctx.setIterValue(items[i], ev));
-    }
-    return args.result(accu);
-  });
-}
-function oFieldAccess(left, right, ast, ev) {
-  const e = ev;
-  return e.optionalType.field(left, right, ast, e);
-}
-function fieldAccessStatic(left, right, ast, ev) {
-  const a = ast;
-  const e = ev;
-  return a.left.checkedType.field(left, right, a, e);
-}
-const empty = /* @__PURE__ */ Object.create(null);
-function fieldAccess(left, right, ast, ev) {
-  const a = ast;
-  const e = ev;
-  switch (left?.constructor) {
-    case void 0:
-    case Object: {
-      const v = hasOwn(left || empty, right) ? left[right] : void 0;
-      if (v !== void 0) return e.debugType(v), v;
-      break;
-    }
-    case Map: {
-      const v = left.get(right);
-      if (v !== void 0) return e.debugType(v), v;
-      break;
-    }
-    case Array:
-    case Set:
-      return e.listType.field(left, right, a, e);
-    default: {
-      const t = e.objectTypesByConstructor.get(left.constructor);
-      if (t) return t.type.field(left, right, a, e);
-      else if (typeof left === "object") unsupportedType(e, left.constructor?.name ?? "object");
-    }
-  }
-  throw e.createError("no_such_key", `No such key: ${right}`, a);
-}
-const emptyList = () => Effect.succeed([]);
-const emptyMap = () => Effect.succeed({});
-const OPERATORS_MAP = {
-  "value": {
-    check(chk, ast) {
-      return chk.debugType(ast.args);
-    },
-    evaluate(_ev, ast) {
-      return Effect.succeed(ast.args);
-    }
-  },
-  "id": {
-    check(chk, ast, ctx) {
-      const variable = ctx.getVariable(ast.args);
-      if (!variable) throw chk.createError("unknown_variable", `Unknown variable: ${ast.args}`, ast);
-      if (variable.constant) {
-        const alternate = ast.clone(OPERATORS_MAP.value, variable.value);
-        ast.setMeta("alternate", alternate);
-        return chk.check(alternate, ctx);
-      }
-      return variable.type;
-    },
-    evaluate(ev, ast, ctx) {
-      return Effect.try({
-        try: () => ctx.getCheckedValue(ev, ast),
-        catch: (e) => e
-      });
-    }
-  },
-  ".": {
-    alias: "fieldAccess",
-    check: checkAccessNode,
-    evaluate: evaluateBinaryFirst
-  },
-  ".?": {
-    alias: "optionalFieldAccess",
-    check: checkOptionalAccessNode,
-    evaluate: evaluateBinaryFirst
-  },
-  "[]": {
-    alias: "bracketAccess",
-    check: checkAccessNode,
-    evaluate: evaluateBinary
-  },
-  "[?]": {
-    alias: "optionalBracketAccess",
-    check: checkOptionalAccessNode,
-    evaluate: evaluateBinary
-  },
-  "call": {
-    check(chk, ast, ctx) {
-      const [functionName, args] = ast.args;
-      const candidates = ast.candidates = chk.registry.functionCandidates(
-        false,
-        functionName,
-        args.length
-      );
-      const argTypes = ast.argTypes = args.map((a) => chk.check(a, ctx));
-      const decl = candidates.findFunction(argTypes);
-      if (!decl) {
-        throw chk.createError(
-          "no_matching_overload",
-          `found no matching overload for '${functionName}(${chk.formatTypeList(argTypes)})'`,
-          ast
-        );
-      }
-      const handle = argTypes.some((t) => t.hasDynType) ? callFn : ((args2, _ast, e) => callFunctionHandler(decl.handler, e, args2, _ast));
-      ast.handle = handle;
-      return decl.returnType;
-    },
-    evaluate(ev, ast, ctx) {
-      return resolveAstArray(ev, ast.args[1], ctx).pipe(
-        Effect.flatMap((args) => ast.handle(args, ast, ev))
-      );
-    }
-  },
-  "rcall": {
-    check(chk, ast, ctx) {
-      const [methodName, receiver, args] = ast.args;
-      const receiverType = chk.check(receiver, ctx);
-      const candidates = ast.candidates = chk.registry.functionCandidates(
-        true,
-        methodName,
-        args.length
-      );
-      const argTypes = ast.argTypes = args.map((a) => chk.check(a, ctx));
-      ast.receiverWithArgs = [receiver, ...args];
-      ast.handle = callRecFn;
-      if (receiverType.kind === "dyn" && candidates.returnType) return candidates.returnType;
-      const decl = candidates.findFunction(argTypes, receiverType);
-      if (!decl) {
-        throw chk.createError(
-          "no_matching_overload",
-          `found no matching overload for '${receiverType.type}.${methodName}(${chk.formatTypeList(
-            argTypes
-          )})'`,
-          ast
-        );
-      }
-      if (!receiverType.hasPlaceholderType && !argTypes.some((t) => t.hasDynType)) {
-        const fn = decl.handler;
-        const handle = (a, ev, _ast) => callFunctionHandler(fn, ev, a, _ast);
-        ast.handle = handle;
-      }
-      return decl.returnType;
-    },
-    evaluate(ev, ast, ctx) {
-      return resolveAstArray(ev, ast.receiverWithArgs, ctx).pipe(
-        Effect.flatMap((args) => ast.handle(args, ev, ast))
-      );
-    }
-  },
-  "list": {
-    check(chk, ast, ctx) {
-      const arr = ast.args;
-      const arrLen = arr.length;
-      if (arrLen === 0) return ast.setMeta("evaluate", emptyList) && chk.getType("list<T>");
-      let valueType = chk.check(arr[0], ctx);
-      for (let i = 1; i < arrLen; i++)
-        valueType = checkElement(chk, ctx, valueType, arr[i]);
-      return chk.registry.getListType(valueType);
-    },
-    evaluate(ev, ast, ctx) {
-      return resolveAstArray(ev, ast.args, ctx);
-    }
-  },
-  "map": {
-    check(chk, ast, ctx) {
-      const arr = ast.args;
-      const arrLen = arr.length;
-      if (arrLen === 0) return ast.setMeta("evaluate", emptyMap) && chk.getType("map<K, V>");
-      let keyType = chk.check(arr[0][0], ctx);
-      let valueType = chk.check(arr[0][1], ctx);
-      for (let i = 1; i < arrLen; i++) {
-        const e = arr[i];
-        keyType = checkElement(chk, ctx, keyType, e[0]);
-        valueType = checkElement(chk, ctx, valueType, e[1]);
-      }
-      return chk.registry.getMapType(keyType, valueType);
-    },
-    evaluate(ev, ast, ctx) {
-      const astEntries = ast.args;
-      return Effect.all(
-        astEntries.map(
-          (e) => Effect.all([ev.eval(e[0], ctx), ev.eval(e[1], ctx)])
-        )
-      ).pipe(Effect.map(safeFromEntries));
-    }
-  },
-  "comprehension": {
-    check(chk, ast, ctx) {
-      const args = ast.args;
-      args.iterCtx = ctx.forkWithVariable(args.iterVarName, comprehensionElementType(chk, args.iterable, ctx)).setAccuType(chk.check(args.init, ctx));
-      const stepType = chk.check(args.step, args.iterCtx);
-      const handler = args.errorsAreFatal ? runComprehension : runQualifier;
-      ast.handle = handler;
-      return args.kind === "quantifier" ? chk.boolType : stepType;
-    },
-    evaluate(ev, ast, ctx) {
-      return ev.eval(ast.args.iterable, ctx).pipe(
-        Effect.flatMap((items) => ast.handle(items, ast.args, ev, ctx))
-      );
-    }
-  },
-  "accuValue": {
-    check(_chk, _ast, ctx) {
-      return ctx.accuType;
-    },
-    evaluate(_ev, _ast, ctx) {
-      return Effect.succeed(ctx.accuValue);
-    }
-  },
-  "accuInc": {
-    check(_chk, _ast, ctx) {
-      return ctx.accuType;
-    },
-    evaluate(_ev, _ast, ctx) {
-      return Effect.succeed(ctx.accuValue = ctx.accuValue + 1);
-    }
-  },
-  "accuPush": {
-    check(chk, ast, ctx) {
-      const listType = ctx.accuType;
-      const itemType = chk.check(ast.args, ctx);
-      if (listType.kind === "list" && listType.valueType.kind !== "param") return listType;
-      return chk.registry.getListType(itemType);
-    },
-    evaluate(ev, ast, ctx) {
-      return ev.eval(ast.args, ctx).pipe(
-        Effect.map((el) => {
-          const arr = ctx.accuValue;
-          arr.push(el);
-          return arr;
-        })
-      );
-    }
-  },
-  "?:": {
-    alias: "ternary",
-    check(chk, ast, ctx) {
-      const condast = ast.condition = ast.args[0];
-      const leftast = ast.left = ast.args[1];
-      const rightast = ast.right = ast.args[2];
-      const condType = chk.check(condast, ctx);
-      if (!condType.isDynOrBool()) {
-        throw chk.createError(
-          "invalid_condition_type",
-          `${condast.meta.label || "Ternary condition must be bool"}, got '${chk.formatType(condType)}'`,
-          condast
-        );
-      }
-      const leftType = chk.check(leftast, ctx);
-      const rightType = chk.check(rightast, ctx);
-      const unified = leftType.unify(chk.registry, rightType);
-      ast.handle = handleTernary;
-      if (unified) return unified;
-      throw chk.createError(
-        "incompatible_ternary_branches",
-        `Ternary branches must have the same type, got '${chk.formatType(
-          leftType
-        )}' and '${chk.formatType(rightType)}'`,
-        ast
-      );
-    },
-    evaluate(ev, ast, ctx) {
-      return ev.eval(ast.condition, ctx).pipe(
-        Effect.flatMap((c) => handleTernary(c, ev, ast, ctx))
-      );
-    }
-  },
-  "||": {
-    check: checkLogicalOp,
-    evaluate(ev, ast, ctx) {
-      return Effect.gen(function* () {
-        const leftResult = yield* ev.tryEval(ast.left, ctx);
-        if (Either.isRight(leftResult)) {
-          const l = leftResult.right;
-          if (l === true) return true;
-          if (l === false) {
-            const right = yield* ev.eval(ast.right, ctx);
-            if (typeof right === "boolean") return right;
-            return yield* Effect.fail(logicalOperandError(ev, right, ast.right));
-          }
-          const rightResult2 = yield* ev.tryEval(ast.right, ctx);
-          if (Either.isRight(rightResult2)) {
-            const r = rightResult2.right;
-            if (r === true) return true;
-            if (typeof r === "boolean") return yield* Effect.fail(logicalOperandError(ev, l, ast.left));
-            return yield* Effect.fail(logicalOperandError(ev, r, ast.right));
-          }
-          return yield* Effect.fail(logicalOperandError(ev, l, ast.left));
-        }
-        const rightResult = yield* ev.tryEval(ast.right, ctx);
-        if (Either.isRight(rightResult)) {
-          const r = rightResult.right;
-          if (r === true) return true;
-          if (r === false) return yield* Effect.fail(leftResult.left);
-          return yield* Effect.fail(logicalOperandError(ev, r, ast.right));
-        }
-        return yield* Effect.fail(leftResult.left);
-      });
-    }
-  },
-  "&&": {
-    check: checkLogicalOp,
-    evaluate(ev, ast, ctx) {
-      return Effect.gen(function* () {
-        const leftResult = yield* ev.tryEval(ast.left, ctx);
-        if (Either.isRight(leftResult)) {
-          const l = leftResult.right;
-          if (l === false) return false;
-          if (l === true) {
-            const right = yield* ev.eval(ast.right, ctx);
-            if (typeof right === "boolean") return right;
-            return yield* Effect.fail(logicalOperandError(ev, right, ast.right));
-          }
-          const rightResult2 = yield* ev.tryEval(ast.right, ctx);
-          if (Either.isRight(rightResult2)) {
-            const r = rightResult2.right;
-            if (r === false) return false;
-            if (typeof r === "boolean") return yield* Effect.fail(logicalOperandError(ev, l, ast.left));
-            return yield* Effect.fail(logicalOperandError(ev, r, ast.right));
-          }
-          return yield* Effect.fail(logicalOperandError(ev, l, ast.left));
-        }
-        const rightResult = yield* ev.tryEval(ast.right, ctx);
-        if (Either.isRight(rightResult)) {
-          const r = rightResult.right;
-          if (r === false) return false;
-          if (r === true) return yield* Effect.fail(leftResult.left);
-          return yield* Effect.fail(logicalOperandError(ev, r, ast.right));
-        }
-        return yield* Effect.fail(leftResult.left);
-      });
-    }
-  },
-  "!_": { alias: "unaryNot", check: checkUnary, evaluate: evaluateUnary },
-  "-_": { alias: "unaryMinus", check: checkUnary, evaluate: evaluateUnary }
-};
-const binaryOperators = ["!=", "==", "in", "+", "-", "*", "/", "%", "<", "<=", ">", ">="];
-for (const op of binaryOperators) OPERATORS_MAP[op] = { check: checkBinary, evaluate: evaluateBinary };
-for (const op of objKeys(OPERATORS_MAP)) {
-  const obj = OPERATORS_MAP[op];
-  obj.name = op;
-  if (obj.alias) OPERATORS_MAP[obj.alias] = obj;
-}
-export const OPERATORS = OPERATORS_MAP;

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

@@ -1,5 +0,0 @@
-import { Option } from 'effect';
-import type { Registry } from './registry.js.js';
-export declare function optionalOf(value: unknown): Option.None<{} | null> | Option.Some<{} | null>;
-export declare function optionalValue(opt: Option.Option<unknown>): unknown;
-export declare function register(registry: Registry): void;