ballerina-core 1.0.204 → 1.0.205

package/bin/src/forms/domains/parser/domains/predicates/state.js

@@ -1,1507 +0,0 @@
-import { Map, Set, List, OrderedMap } from "immutable";
-import {
-  ValueOrErrors,
-  MapRepo,
-  Updater,
-  simpleUpdater,
-  replaceWith,
-  ListRepo,
-} from "../../../../../../main";
-const calculateVisibility = (expr, bindings) => {
-  if (typeof expr == "boolean") {
-    return ValueOrErrors.Default.return(expr);
-  }
-  return Expr.Operations.Evaluate(bindings)(expr).Then((result) => {
-    if (typeof result == "boolean") {
-      return ValueOrErrors.Default.return(result);
-    }
-    return ValueOrErrors.Default.throwOne(
-      `Error: cannot evaluate expression ${JSON.stringify(expr)} to a boolean`,
-    );
-  });
-};
-export const FieldPredicateExpression = {
-  Default: {
-    unit: (value) => ({ kind: "unit", value }),
-    primitive: (value) => ({
-      kind: "primitive",
-      value,
-    }),
-    record: (value, fields) => ({ kind: "record", value, fields }),
-    list: (value, elementExpression) => ({
-      kind: "list",
-      value,
-      elementExpression,
-    }),
-    map: (value, keyExpression, valueExpression) => ({
-      kind: "map",
-      value,
-      keyExpression,
-      valueExpression,
-    }),
-    tuple: (value, elementExpressions) => ({
-      kind: "tuple",
-      value,
-      elementExpressions,
-    }),
-    sum: (value, leftExpression, rightExpression) => ({
-      kind: "sum",
-      value,
-      leftExpression:
-        leftExpression !== null && leftExpression !== void 0
-          ? leftExpression
-          : FieldPredicateExpression.Default.unit(false),
-      rightExpression:
-        rightExpression !== null && rightExpression !== void 0
-          ? rightExpression
-          : FieldPredicateExpression.Default.unit(false),
-    }),
-  },
-};
-export const FormFieldPredicateEvaluation = {
-  Default: {
-    unit: (value) => ({
-      kind: "unit",
-      value,
-    }),
-    primitive: (value) => ({
-      kind: "primitive",
-      value,
-    }),
-    form: (value, fields) => ({ kind: "form", value, fields }),
-    list: (value, elementValues) => ({
-      kind: "list",
-      value,
-      elementValues,
-    }),
-    map: (value, elementValues) => ({ kind: "map", value, elementValues }),
-    tuple: (value, elementValues) => ({
-      kind: "tuple",
-      value,
-      elementValues,
-    }),
-    sum: (value, innerValue) => ({ kind: "sum", value, innerValue }),
-  },
-};
-export const ValueRecord = {
-  Default: {
-    empty: () => ({ kind: "record", fields: OrderedMap() }),
-    fromJSON: (json) => ({
-      kind: "record",
-      fields: OrderedMap(Object.assign({}, json)), // TODO - check this works ok
-    }),
-    fromMap: (map) => ({
-      kind: "record",
-      fields: OrderedMap(map),
-    }),
-  },
-  Operations: {
-    has: (record, key) => {
-      return record.fields.has(key);
-    },
-  },
-  Updaters: Object.assign(Object.assign({}, simpleUpdater()("fields")), {
-    update: (key, updater) => {
-      return ValueRecord.Updaters.fields(MapRepo.Updaters.update(key, updater));
-    },
-    set: (key, value) => {
-      return ValueRecord.Updaters.fields(MapRepo.Updaters.set(key, value));
-    },
-    remove: (key) => {
-      return ValueRecord.Updaters.fields(MapRepo.Updaters.remove(key));
-    },
-    clear: () => {
-      return ValueRecord.Updaters.fields(replaceWith(OrderedMap()));
-    },
-  }),
-};
-export const ValueUnionCase = {
-  Default: (caseName, fields) => ({
-    kind: "unionCase",
-    caseName,
-    fields,
-  }),
-  Updaters: Object.assign(
-    {
-      case: (caseName) => (upd) =>
-        Updater((v) => ValueUnionCase.Default(caseName, upd(v.fields))),
-    },
-    simpleUpdater()("fields"),
-  ),
-};
-export const ValueUnit = {
-  Default: () => ({ kind: "unit" }),
-};
-export const ValueOption = {
-  Default: {
-    some: (value) => ({
-      kind: "option",
-      isSome: true,
-      value,
-    }),
-    none: () => ({
-      kind: "option",
-      isSome: false,
-      value: { kind: "unit" },
-    }),
-  },
-  Updaters: {
-    value: (_) => Updater((v) => ValueOption.Default.some(_(v))),
-  },
-};
-export const ValueSum = {
-  Default: (value) => ({
-    kind: "sum",
-    value,
-  }),
-  Updaters: Object.assign({}, simpleUpdater()("value")),
-};
-export const ValueSumN = {
-  Default: (caseIndex, arity, value) => ({
-    kind: "sumN",
-    caseIndex,
-    arity,
-    value,
-  }),
-  Updaters: Object.assign(
-    {
-      case: (caseIndex) => (upd) =>
-        Updater((v) => ValueSumN.Default(caseIndex, v.arity, upd(v.value))),
-    },
-    simpleUpdater()("value"),
-  ),
-};
-export const ValueTuple = {
-  Default: () => ({
-    kind: "tuple",
-    values: List(),
-  }),
-  Updaters: Object.assign({}, simpleUpdater()("values")),
-};
-export const ValueTable = {
-  Default: {
-    empty: () => ({
-      kind: "table",
-      from: 0,
-      to: 0,
-      data: OrderedMap(),
-      hasMoreValues: false,
-    }),
-    fromParsed: (from, to, hasMoreValues, data) => ({
-      kind: "table",
-      from,
-      to,
-      data,
-      hasMoreValues,
-    }),
-  },
-  Updaters: Object.assign({}, simpleUpdater()("data")),
-};
-export const ValueFilterContains = {
-  Default: (contains) => ({
-    kind: "contains",
-    contains,
-  }),
-};
-export const ValueFilterEqualsTo = {
-  Default: (equalsTo) => ({
-    kind: "=",
-    equalsTo,
-  }),
-};
-export const ValueFilterNotEqualsTo = {
-  Default: (notEqualsTo) => ({
-    kind: "!=",
-    notEqualsTo,
-  }),
-};
-export const ValueFilterGreaterThanOrEqualsTo = {
-  Default: (greaterThanOrEqualsTo) => ({
-    kind: ">=",
-    greaterThanOrEqualsTo,
-  }),
-};
-export const ValueFilterGreaterThan = {
-  Default: (greaterThan) => ({
-    kind: ">",
-    greaterThan,
-  }),
-};
-export const ValueFilterIsNotNull = {
-  Default: () => ({
-    kind: "!=null",
-  }),
-};
-export const ValueFilterIsNull = {
-  Default: () => ({
-    kind: "=null",
-  }),
-};
-export const ValueFilterSmallerThanOrEqualsTo = {
-  Default: (smallerThanOrEqualsTo) => ({
-    kind: "<=",
-    smallerThanOrEqualsTo,
-  }),
-};
-export const ValueFilterSmallerThan = {
-  Default: (smallerThan) => ({
-    kind: "<",
-    smallerThan,
-  }),
-};
-export const ValueFilterStartsWith = {
-  Default: (startsWith) => ({
-    kind: "startsWith",
-    startsWith,
-  }),
-};
-export const BinaryOperators = ["or", "equals"];
-export const BinaryOperatorsSet = Set(BinaryOperators);
-export const PredicateValue = {
-  Default: {
-    string: () => "",
-    number: () => 0,
-    boolean: () => false,
-    date: () => new Date(),
-    unit: () => ({ kind: "unit" }),
-    tuple: (values) => ({
-      kind: "tuple",
-      values,
-    }),
-    record: (fields) => ({
-      kind: "record",
-      fields,
-    }),
-    unionCase: (caseName, fields) => ({
-      kind: "unionCase",
-      caseName,
-      fields,
-    }),
-    option: (isSome, value) => ({
-      kind: "option",
-      isSome,
-      value,
-    }),
-    varLookup: (varName) => ({
-      kind: "varLookup",
-      varName,
-    }),
-    sum: (value) => ({
-      kind: "sum",
-      value,
-    }),
-    sumN: (caseIndex, arity, value) => ({
-      kind: "sumN",
-      caseIndex,
-      arity,
-      value,
-    }),
-    table: (from, to, data, hasMoreValues) => ({
-      kind: "table",
-      from,
-      to,
-      data,
-      hasMoreValues,
-    }),
-    readonly: (value) => ({
-      kind: "readOnly",
-      ReadOnly: value,
-    }),
-    filterContains: (contains) => ({
-      kind: "contains",
-      contains,
-    }),
-    filterEqualsTo: (equalsTo) => ({
-      kind: "=",
-      equalsTo,
-    }),
-    filterNotEqualsTo: (notEqualsTo) => ({
-      kind: "!=",
-      notEqualsTo,
-    }),
-    filterGreaterThanOrEqualsTo: (greaterThanOrEqualsTo) => ({
-      kind: ">=",
-      greaterThanOrEqualsTo,
-    }),
-    filterGreaterThan: (greaterThan) => ({
-      kind: ">",
-      greaterThan,
-    }),
-    filterIsNotNull: () => ({
-      kind: "!=null",
-    }),
-    filterIsNull: () => ({
-      kind: "=null",
-    }),
-    filterSmallerThanOrEqualsTo: (smallerThanOrEqualsTo) => ({
-      kind: "<=",
-      smallerThanOrEqualsTo,
-    }),
-    filterSmallerThan: (smallerThan) => ({
-      kind: "<",
-      smallerThan,
-    }),
-    filterStartsWith: (startsWith) => ({
-      kind: "startsWith",
-      startsWith,
-    }),
-  },
-  Operations: {
-    GetKind: (value) =>
-      typeof value == "object"
-        ? "kind" in value
-          ? ValueOrErrors.Default.return(value.kind)
-          : PredicateValue.Operations.IsDate(value)
-            ? ValueOrErrors.Default.return("date")
-            : ValueOrErrors.Default.throwOne("invalid")
-        : ValueOrErrors.Default.return(typeof value),
-    IsPrimitive: (value) => {
-      return (
-        PredicateValue.Operations.IsBoolean(value) ||
-        PredicateValue.Operations.IsNumber(value) ||
-        PredicateValue.Operations.IsString(value) ||
-        PredicateValue.Operations.IsDate(value)
-      );
-    },
-    IsBoolean: (value) => {
-      return typeof value == "boolean";
-    },
-    IsNumber: (value) => {
-      return typeof value == "number";
-    },
-    IsString: (value) => {
-      return typeof value == "string";
-    },
-    IsDate: (value) => {
-      return (
-        typeof value == "object" &&
-        Object.prototype.toString.call(value) === "[object Date]" &&
-        value instanceof Date &&
-        !isNaN(value.getTime())
-      );
-    },
-    IsUnit: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "unit"
-      );
-    },
-    IsUnionCase: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "unionCase"
-      );
-    },
-    IsRecord: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "record"
-      );
-    },
-    IsTuple: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "tuple"
-      );
-    },
-    IsOption: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "option"
-      );
-    },
-    IsTable: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "table"
-      );
-    },
-    IsSum: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "sum"
-      );
-    },
-    IsSumN: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "sumN"
-      );
-    },
-    IsVarLookup: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "varLookup"
-      );
-    },
-    IsCustom: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "custom"
-      );
-    },
-    IsReadOnly: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "readOnly"
-      );
-    },
-    IsFilterContains: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "contains"
-      );
-    },
-    IsFilterEqualsTo: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "="
-      );
-    },
-    IsFilterNotEqualsTo: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "!="
-      );
-    },
-    IsFilterGreaterThanOrEqualsTo: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == ">="
-      );
-    },
-    IsFilterGreaterThan: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == ">"
-      );
-    },
-    IsFilterIsNotNull: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "!=null"
-      );
-    },
-    IsFilterIsNull: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "=null"
-      );
-    },
-    IsFilterSmallerThanOrEqualsTo: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "<="
-      );
-    },
-    IsFilterSmallerThan: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "<"
-      );
-    },
-    IsFilterStartsWith: (value) => {
-      return (
-        typeof value == "object" &&
-        !PredicateValue.Operations.IsDate(value) &&
-        value.kind == "startsWith"
-      );
-    },
-    KindAndValueToFilter: (kind, value) => {
-      switch (kind) {
-        case "contains":
-          return PredicateValue.Default.filterContains(value);
-        case "=":
-          return PredicateValue.Default.filterEqualsTo(value);
-        case "!=":
-          return PredicateValue.Default.filterNotEqualsTo(value);
-        case ">=":
-          return PredicateValue.Default.filterGreaterThanOrEqualsTo(value);
-        case ">":
-          return PredicateValue.Default.filterGreaterThan(value);
-        case "!=null":
-          return PredicateValue.Default.filterIsNotNull();
-        case "=null":
-          return PredicateValue.Default.filterIsNull();
-        case "<=":
-          return PredicateValue.Default.filterSmallerThanOrEqualsTo(value);
-        case "<":
-          return PredicateValue.Default.filterSmallerThan(value);
-        case "startsWith":
-          return PredicateValue.Default.filterStartsWith(value);
-        default:
-          return PredicateValue.Default.filterEqualsTo(value);
-      }
-    },
-    ParseAsDate: (json) => {
-      if (PredicateValue.Operations.IsDate(json))
-        return ValueOrErrors.Default.return(json);
-      return ValueOrErrors.Default.throwOne(`date has invalid value property`);
-    },
-    ParseAsVarLookup: (json) => {
-      if (json.kind == "varLookup" && typeof json.varName == "string")
-        return ValueOrErrors.Default.return(
-          PredicateValue.Default.varLookup(json.varName),
-        );
-      return ValueOrErrors.Default.throwOne(
-        `varLookup has invalid varName property`,
-      );
-    },
-    ParseAsUnionCase: (json) => {
-      if (typeof json.caseName == "string")
-        return ValueOrErrors.Default.return(
-          PredicateValue.Default.unionCase(json.caseName, json.value),
-        );
-      return ValueOrErrors.Default.throwOne(
-        `union case has invalid caseName property`,
-      );
-    },
-    ParseAsRecord: (json, types) => {
-      if ("fields" in json && typeof json.fields == "object") {
-        return ValueOrErrors.Operations.All(
-          List(
-            Object.entries(json.fields).map(([fieldName, fieldValue]) =>
-              PredicateValue.Operations.parse(
-                fieldValue,
-                { kind: "expression" },
-                types,
-              ).Then((value) =>
-                ValueOrErrors.Default.return([fieldName, value]),
-              ),
-            ),
-          ),
-        ).Then((entries) =>
-          ValueOrErrors.Default.return(
-            PredicateValue.Default.record(OrderedMap(entries)),
-          ),
-        );
-      }
-      return ValueOrErrors.Default.throwOne(`record has no field property`);
-    },
-    ParseAsTuple: (json, types) => {
-      if (json.values != undefined && Array.isArray(json.values)) {
-        return ValueOrErrors.Operations.All(
-          List(
-            json.values.map((elementValue) =>
-              PredicateValue.Operations.parse(
-                elementValue,
-                { kind: "expression" },
-                types,
-              ),
-            ),
-          ),
-        ).Then((values) =>
-          ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
-        );
-      }
-      return ValueOrErrors.Default.throwOne(
-        `Error: tuple has no values property`,
-      );
-    },
-    // TODO -- do we need to add table here ?
-    parse: (json, type, types) => {
-      const result = (() => {
-        if (
-          type.kind == "expression" &&
-          (typeof json == "boolean" ||
-            typeof json == "number" ||
-            typeof json == "string")
-        )
-          return ValueOrErrors.Default.return(json);
-        if (type.kind == "expression" && json.kind == undefined) {
-          return ValueOrErrors.Default.throwOne(
-            `evaluation statement has no kind value`,
-          );
-        }
-        if (type.kind == "expression" && json.kind == "guid") {
-          return ValueOrErrors.Default.return(json);
-        }
-        if (type.kind == "expression" && json.kind == "date") {
-          return PredicateValue.Operations.ParseAsDate(json);
-        }
-        if (type.kind == "expression" && json.kind == "unit") {
-          return ValueOrErrors.Default.return(PredicateValue.Default.unit());
-        }
-        if (type.kind == "expression" && json.kind == "varLookup") {
-          return PredicateValue.Operations.ParseAsVarLookup(json);
-        }
-        if (
-          type.kind == "expression" &&
-          json.kind == "record" &&
-          "caseName" in json
-        ) {
-          return PredicateValue.Operations.ParseAsUnionCase(json);
-        }
-        if (
-          type.kind == "expression" &&
-          json.kind == "record" &&
-          "fields" in json
-        ) {
-          return PredicateValue.Operations.ParseAsRecord(json, types);
-        }
-        if (
-          type.kind == "expression" &&
-          json.kind == "tuple" &&
-          "values" in json
-        ) {
-          return PredicateValue.Operations.ParseAsTuple(json, types);
-        }
-        if (type.kind == "primitive" && type.value == "Date") {
-          if (PredicateValue.Operations.IsDate(json)) {
-            return ValueOrErrors.Default.return(json);
-          }
-          return ValueOrErrors.Default.throwOne(
-            `failed to parse date ${JSON.stringify(json)}`,
-          );
-        }
-        if (type.kind == "primitive" && type.value == "maybeBoolean") {
-          return json == undefined
-            ? ValueOrErrors.Default.return(false)
-            : ValueOrErrors.Default.return(json);
-        }
-        if (type.kind == "primitive") {
-          return ValueOrErrors.Default.return(json);
-        }
-        if (type.kind == "lookup") {
-          const subType = types.get(type.name);
-          if (subType == undefined) {
-            return ValueOrErrors.Default.throwOne(
-              `cannot find field ${type.name} in types`,
-            );
-          }
-          return PredicateValue.Operations.parse(json, subType, types);
-        }
-        if (type.kind == "union") {
-          const unionCase = type.args.get(json);
-          if (unionCase == undefined) {
-            return ValueOrErrors.Default.throwOne(
-              `Error: cannot find union case ${JSON.stringify(json)} in types`,
-            );
-          }
-          return PredicateValue.Operations.ParseAsUnionCase({
-            kind: "unionCase",
-            caseName: json,
-            value: { kind: "form", value: Map() },
-          });
-        }
-        if (type.kind == "application" && type.value == "List") {
-          return ValueOrErrors.Operations.All(
-            List(
-              json.map((elementValue) =>
-                PredicateValue.Operations.parse(
-                  elementValue,
-                  type.args[0],
-                  types,
-                ),
-              ),
-            ),
-          ).Then((values) =>
-            ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
-          );
-        }
-        if (type.kind == "application" && type.value == "Map") {
-          return ValueOrErrors.Operations.All(
-            List(
-              json.map((keyValue) =>
-                PredicateValue.Operations.parse(
-                  keyValue.key,
-                  type.args[0],
-                  types,
-                ).Then((key) =>
-                  PredicateValue.Operations.parse(
-                    keyValue.value,
-                    type === null || type === void 0 ? void 0 : type.args[1],
-                    types,
-                  ).Then((value) =>
-                    ValueOrErrors.Default.return(
-                      PredicateValue.Default.tuple(List([key, value])),
-                    ),
-                  ),
-                ),
-              ),
-            ),
-          ).Then((values) =>
-            ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
-          );
-        }
-        if (type.kind == "application" && type.value == "Sum") {
-          return PredicateValue.Operations.parse(
-            json.left,
-            type === null || type === void 0 ? void 0 : type.args[0],
-            types,
-          ).Then((left) =>
-            PredicateValue.Operations.parse(
-              json.right,
-              type === null || type === void 0 ? void 0 : type.args[1],
-              types,
-            ).Then((right) =>
-              ValueOrErrors.Default.return(
-                PredicateValue.Default.tuple(List([left, right])),
-              ),
-            ),
-          );
-        }
-        if (type.kind == "application" && type.value == "SingleSelection") {
-          ValueOrErrors.Default.return(
-            PredicateValue.Default.option(json["IsSome"], json["Value"]),
-          );
-        }
-        if (type.kind == "application" && type.value == "MultiSelection") {
-          return ValueOrErrors.Operations.All(
-            List(
-              json.map((elementValue) =>
-                PredicateValue.Operations.parse(
-                  elementValue,
-                  type.args[0],
-                  types,
-                ),
-              ),
-            ),
-          ).Then((values) =>
-            ValueOrErrors.Default.return(PredicateValue.Default.tuple(values)),
-          );
-        }
-        if (type.kind == "record") {
-          return ValueOrErrors.Operations.All(
-            List(
-              Object.entries(json).map(([fieldName, fieldValue]) => {
-                const subType = type.fields.get(fieldName);
-                if (subType == undefined) {
-                  return ValueOrErrors.Default.throwOne(
-                    `cannot find field ${fieldName} in type ${JSON.stringify(type)}`,
-                  );
-                }
-                return PredicateValue.Operations.parse(
-                  fieldValue,
-                  subType,
-                  types,
-                ).Then((value) =>
-                  ValueOrErrors.Default.return([fieldName, value]),
-                );
-              }),
-            ),
-          ).Then((entries) =>
-            ValueOrErrors.Default.return(
-              PredicateValue.Default.record(
-                OrderedMap(entries.map((_) => [_[0], _[1]])),
-              ),
-            ),
-          );
-        }
-        return ValueOrErrors.Default.throwOne(
-          `unsupported type ${JSON.stringify(type)}`,
-        );
-      })();
-      return result.MapErrors((errors) =>
-        errors.map(
-          (error) =>
-            `${error}\n...When parsing expression ${JSON.stringify(json, null, 2)}`,
-        ),
-      );
-    },
-    recordToTuple: (r) => {
-      const valuesSortedByName = r.fields
-        .toSeq()
-        .map((v, k) => [k, v])
-        .sortBy(([k, v]) => k)
-        .map(([k, v]) => v)
-        .valueSeq()
-        .toArray();
-      return PredicateValue.Default.tuple(List(valuesSortedByName));
-    },
-    Equals: (vars) => (v1, v2) =>
-      typeof v1 == "boolean" ||
-      typeof v1 == "number" ||
-      typeof v1 == "string" ||
-      typeof v2 == "boolean" ||
-      typeof v2 == "number" ||
-      typeof v2 == "string"
-        ? typeof v1 == typeof v2
-          ? ValueOrErrors.Default.return(v1 == v2)
-          : ValueOrErrors.Default.throwOne(
-              `cannot compare expressions of different types ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`,
-            )
-        : PredicateValue.Operations.IsDate(v1) &&
-            PredicateValue.Operations.IsDate(v2)
-          ? v1.getTime() == v2.getTime()
-            ? ValueOrErrors.Default.return(true)
-            : ValueOrErrors.Default.return(false)
-          : PredicateValue.Operations.IsUnionCase(v1) &&
-              PredicateValue.Operations.IsUnionCase(v2)
-            ? v1.caseName == v2.caseName
-              ? PredicateValue.Operations.Equals(vars)(v1.fields, v2.fields)
-              : ValueOrErrors.Default.return(false)
-            : PredicateValue.Operations.IsTuple(v1) &&
-                PredicateValue.Operations.IsTuple(v2)
-              ? v1.values.size != v2.values.size
-                ? ValueOrErrors.Default.return(false)
-                : v1.values.size == 0
-                  ? ValueOrErrors.Default.return(true)
-                  : PredicateValue.Operations.Equals(vars)(
-                      v1.values.get(0),
-                      v2.values.get(0),
-                    ).Then((firstEqual) =>
-                      firstEqual
-                        ? PredicateValue.Operations.Equals(vars)(
-                            PredicateValue.Default.tuple(v1.values.slice(1)),
-                            PredicateValue.Default.tuple(v2.values.slice(1)),
-                          )
-                        : ValueOrErrors.Default.return(false),
-                    )
-              : PredicateValue.Operations.IsRecord(v1) &&
-                  PredicateValue.Operations.IsRecord(v2)
-                ? PredicateValue.Operations.Equals(vars)(
-                    PredicateValue.Operations.recordToTuple(v1),
-                    PredicateValue.Operations.recordToTuple(v2),
-                  )
-                : PredicateValue.Operations.IsTable(v1) &&
-                    PredicateValue.Operations.IsTable(v2)
-                  ? v1.data.size == v2.data.size
-                    ? ValueOrErrors.Default.return(
-                        v1.data.keySeq().equals(v2.data.keySeq()),
-                      )
-                    : ValueOrErrors.Default.return(false)
-                  : PredicateValue.Operations.IsUnit(v1) &&
-                      PredicateValue.Operations.IsUnit(v2)
-                    ? ValueOrErrors.Default.return(true)
-                    : PredicateValue.Operations.IsUnit(v1) !=
-                        PredicateValue.Operations.IsUnit(v2)
-                      ? ValueOrErrors.Default.throwOne(
-                          `cannot compare expressions of different types ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`,
-                        )
-                      : ValueOrErrors.Default.throwOne(
-                          `structural equality is not implemented yet between ${JSON.stringify(v1)} and ${JSON.stringify(v2)}.`,
-                        ),
-  },
-};
-export const Expr = {
-  Default: {
-    itemLookup: (e, i) => ({
-      kind: "itemLookup",
-      operands: [e, i],
-    }),
-    fieldLookup: (e, f) => ({
-      kind: "fieldLookup",
-      operands: [e, f],
-    }),
-    isCase: (e, c) => ({
-      kind: "isCase",
-      operands: [e, c],
-    }),
-    binaryOperator: (op, e1, e2) => ({
-      kind: op,
-      operands: [e1, e2],
-    }),
-    matchCase: (operands) => ({
-      kind: "matchCase",
-      operands,
-    }),
-    lambda: (parameter, body) => ({
-      kind: "lambda",
-      parameter,
-      body,
-    }),
-    case: (caseName, handler) => ({
-      kind: "caseName",
-      caseName,
-      handler,
-    }),
-  },
-  Operations: {
-    IsItemLookup: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "itemLookup"
-      );
-    },
-    IsFieldLookup: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "fieldLookup"
-      );
-    },
-    IsIsCase: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "isCase"
-      );
-    },
-    IsBinaryOperator: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        BinaryOperatorsSet.has(e.kind)
-      );
-    },
-    IsCase: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "caseName"
-      );
-    },
-    IsCaseArray: (e) => {
-      return e.every((e) => Expr.Operations.IsCase(e));
-    },
-    AsCaseArray: (e) => {
-      return e.every((e) => Expr.Operations.IsCase(e))
-        ? ValueOrErrors.Default.return(e)
-        : ValueOrErrors.Default.throwOne(
-            `Error: expected cases, got ${JSON.stringify(e)}`,
-          );
-    },
-    IsMatchCase: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "matchCase"
-      );
-    },
-    IsLambda: (e) => {
-      return (
-        typeof e == "object" &&
-        !PredicateValue.Operations.IsDate(e) &&
-        e.kind == "lambda"
-      );
-    },
-    parseAsVisibilityExpression: (json) =>
-      Expr.Operations.parse(json).MapErrors((errors) =>
-        errors.map(
-          (error) => `${error}\n...When parsing visibility expression`,
-        ),
-      ),
-    parseAsDisabledExpression: (json) =>
-      Expr.Operations.parse(json).MapErrors((errors) =>
-        errors.map((error) => `${error}\n...When parsing disabled expression`),
-      ),
-    parse: (json) => {
-      const asValue = PredicateValue.Operations.parse(
-        json,
-        { kind: "expression" },
-        Map(),
-      );
-      if (asValue.kind == "value") return asValue;
-      if (Expr.Operations.IsItemLookup(json)) {
-        const [first, second] = json["operands"];
-        return Expr.Operations.parse(first).Then((first) =>
-          ValueOrErrors.Default.return(
-            // Tuples are 1-indexed
-            Expr.Default.itemLookup(first, second - 1),
-          ),
-        );
-      }
-      if (Expr.Operations.IsFieldLookup(json)) {
-        const [first, second] = json["operands"];
-        return Expr.Operations.parse(first).Then((first) =>
-          ValueOrErrors.Default.return(Expr.Default.fieldLookup(first, second)),
-        );
-      }
-      if (Expr.Operations.IsIsCase(json)) {
-        const [first, second] = json["operands"];
-        return Expr.Operations.parse(first).Then((first) =>
-          ValueOrErrors.Default.return(Expr.Default.isCase(first, second)),
-        );
-      }
-      if (Expr.Operations.IsBinaryOperator(json)) {
-        const [first, second] = json["operands"];
-        if (BinaryOperatorsSet.contains(json["kind"])) {
-          return Expr.Operations.parse(first).Then((first) =>
-            Expr.Operations.parse(second).Then((second) =>
-              ValueOrErrors.Default.return(
-                Expr.Default.binaryOperator(json["kind"], first, second),
-              ),
-            ),
-          );
-        }
-      }
-      if (Expr.Operations.IsMatchCase(json)) {
-        return ValueOrErrors.Operations.All(
-          List(
-            json["operands"].map((operand) => Expr.Operations.parse(operand)),
-          ),
-        ).Then((operands) =>
-          ValueOrErrors.Default.return(
-            Expr.Default.matchCase(operands.toArray()),
-          ),
-        );
-      }
-      if (Expr.Operations.IsLambda(json)) {
-        return Expr.Operations.parse(json["body"]).Then((body) =>
-          ValueOrErrors.Default.return(
-            Expr.Default.lambda(json["parameter"], body),
-          ),
-        );
-      }
-      if (Expr.Operations.IsCase(json)) {
-        return Expr.Operations.parse(json["handler"]).Then((handler) =>
-          Expr.Operations.IsLambda(handler)
-            ? ValueOrErrors.Default.return(
-                Expr.Default.case(json["caseName"], handler),
-              )
-            : ValueOrErrors.Default.throwOne(
-                `expected lambda expression, got ${JSON.stringify(handler)}`,
-              ),
-        );
-      }
-      return ValueOrErrors.Default.throwOne(
-        `cannot parse ${JSON.stringify(json)} to Expr.`,
-      );
-    },
-    EvaluateAsTuple: (vars) => (e) =>
-      !PredicateValue.Operations.IsTuple(e)
-        ? ValueOrErrors.Default.throwOne(
-            `expected tuple expression, got ${JSON.stringify(e)}`,
-          )
-        : ValueOrErrors.Default.return(e),
-    EvaluateAsRecord: (vars) => (e) =>
-      !PredicateValue.Operations.IsRecord(e)
-        ? ValueOrErrors.Default.throwOne(
-            `expected record expression, got ${JSON.stringify(e)}`,
-          )
-        : ValueOrErrors.Default.return(e),
-    EvaluateAsUnionCase: (vars) => (e) =>
-      !PredicateValue.Operations.IsUnionCase(e)
-        ? ValueOrErrors.Default.throwOne(
-            `expected union case expression, got ${JSON.stringify(e)}`,
-          )
-        : ValueOrErrors.Default.return(e),
-    EvaluateAsBoolean: (vars) => (e) =>
-      !PredicateValue.Operations.IsBoolean(e)
-        ? ValueOrErrors.Default.throwOne(
-            `expected boolean expression, got ${JSON.stringify(e)}`,
-          )
-        : ValueOrErrors.Default.return(e),
-    MatchCase: (vars) => (e, cases) =>
-      Expr.Operations.Evaluate(vars)(e).Then((matchable) =>
-        PredicateValue.Operations.IsSum(matchable)
-          ? matchable.value.kind == "l"
-            ? MapRepo.Operations.tryFindWithError(
-                "Sum.Left",
-                cases,
-                () => `cannot find match case Sum.Left`,
-              ).Then((leftCaseHandler) =>
-                Expr.Operations.Evaluate(
-                  vars.set(leftCaseHandler.parameter, matchable.value.value),
-                )(leftCaseHandler),
-              )
-            : MapRepo.Operations.tryFindWithError(
-                "Sum.Right",
-                cases,
-                () => `cannot find match case Sum.Right`,
-              ).Then((rightCaseHandler) =>
-                Expr.Operations.Evaluate(
-                  vars.set(rightCaseHandler.parameter, matchable.value.value),
-                )(rightCaseHandler),
-              )
-          : PredicateValue.Operations.IsUnionCase(matchable)
-            ? MapRepo.Operations.tryFindWithError(
-                matchable.caseName,
-                cases,
-                () => `cannot find match case ${matchable.caseName}`,
-              ).Then((matchedCaseHandler) =>
-                Expr.Operations.Evaluate(
-                  vars.set(matchedCaseHandler.parameter, matchable.fields),
-                )(matchedCaseHandler),
-              )
-            : ValueOrErrors.Default.throwOne(
-                `unsupported matchable type in MatchCase: ${JSON.stringify(matchable)}`,
-              ),
-      ),
-    ComputePredicateEvaluation: (vars) => (expr) => {
-      if (typeof expr == "boolean") {
-        return ValueOrErrors.Default.return(expr);
-      }
-      return Expr.Operations.Evaluate(vars)(expr).Then((result) => {
-        if (typeof result == "boolean") {
-          return ValueOrErrors.Default.return(result);
-        }
-        return ValueOrErrors.Default.throwOne(
-          `Error: cannot evaluate expression ${JSON.stringify(expr)} to a boolean`,
-        );
-      });
-    },
-    EvaluateAs: (as) => (vars) => (e) => {
-      return Expr.Operations.Evaluate(vars)(e).MapErrors((errors) =>
-        errors.map(
-          (error) =>
-            `${error}\n...When evaluating expression ${JSON.stringify(e)} as ${as}`,
-        ),
-      );
-    },
-    Evaluate: (vars) => (e) => {
-      const result = (() => {
-        return PredicateValue.Operations.IsBoolean(e) ||
-          PredicateValue.Operations.IsNumber(e) ||
-          PredicateValue.Operations.IsString(e) ||
-          PredicateValue.Operations.IsUnit(e) ||
-          PredicateValue.Operations.IsRecord(e) ||
-          PredicateValue.Operations.IsTuple(e) ||
-          PredicateValue.Operations.IsUnionCase(e) ||
-          PredicateValue.Operations.IsUnit(e) ||
-          PredicateValue.Operations.IsSum(e)
-          ? ValueOrErrors.Default.return(e)
-          : PredicateValue.Operations.IsVarLookup(e)
-            ? MapRepo.Operations.tryFindWithError(
-                e.varName,
-                vars,
-                () =>
-                  `Error: cannot find variable ${JSON.stringify(e.varName)}`,
-              )
-            : Expr.Operations.IsItemLookup(e)
-              ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                  (maybeTuple) =>
-                    Expr.Operations.EvaluateAsTuple(vars)(maybeTuple).Then(
-                      (tuple) =>
-                        ListRepo.Operations.tryFindWithError(
-                          e.operands[1],
-                          tuple.values,
-                          () =>
-                            `Error: cannot find element of index ${e.operands[1]} in tuple ${JSON.stringify(tuple)}`,
-                        ),
-                    ),
-                )
-              : Expr.Operations.IsFieldLookup(e)
-                ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                    (maybeRecord) =>
-                      Expr.Operations.EvaluateAsRecord(vars)(maybeRecord).Then(
-                        (record) =>
-                          MapRepo.Operations.tryFindWithError(
-                            e.operands[1],
-                            record.fields,
-                            () => `Error: cannot find field ${e.operands[1]}`,
-                          ),
-                      ),
-                  )
-                : Expr.Operations.IsIsCase(e)
-                  ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                      (maybeUnionCase) =>
-                        Expr.Operations.EvaluateAsUnionCase(vars)(
-                          maybeUnionCase,
-                        ).Then((unionCase) =>
-                          ValueOrErrors.Default.return(
-                            unionCase.caseName == e.operands[1],
-                          ),
-                        ),
-                    )
-                  : Expr.Operations.IsMatchCase(e)
-                    ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                        (matchable) =>
-                          Expr.Operations.AsCaseArray(e.operands.slice(1)).Then(
-                            (cases) =>
-                              Expr.Operations.MatchCase(vars)(
-                                matchable,
-                                Map(cases.map((c) => [c.caseName, c.handler])),
-                              ),
-                          ),
-                      )
-                    : Expr.Operations.IsLambda(e)
-                      ? Expr.Operations.Evaluate(vars)(e.body)
-                      : Expr.Operations.IsBinaryOperator(e) &&
-                          e.kind == "equals"
-                        ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                            (v1) =>
-                              Expr.Operations.Evaluate(vars)(
-                                e.operands[1],
-                              ).Then((v2) =>
-                                PredicateValue.Operations.Equals(vars)(
-                                  v1,
-                                  v2,
-                                ).Then((eq) =>
-                                  ValueOrErrors.Default.return(eq),
-                                ),
-                              ),
-                          )
-                        : Expr.Operations.IsBinaryOperator(e) && e.kind == "or"
-                          ? Expr.Operations.Evaluate(vars)(e.operands[0]).Then(
-                              (v1) =>
-                                Expr.Operations.Evaluate(vars)(
-                                  e.operands[1],
-                                ).Then((v2) =>
-                                  Expr.Operations.EvaluateAsBoolean(vars)(
-                                    v1,
-                                  ).Then((v1) =>
-                                    Expr.Operations.EvaluateAsBoolean(vars)(
-                                      v2,
-                                    ).Then((v2) =>
-                                      ValueOrErrors.Default.return(v1 || v2),
-                                    ),
-                                  ),
-                                ),
-                            )
-                          : ValueOrErrors.Default.throwOne(
-                              `Error: unsupported expression ${JSON.stringify(e)}`,
-                            );
-      })();
-      return result.MapErrors((errors) =>
-        errors.map(
-          (error) =>
-            `${error}\n...When evaluating expression ${JSON.stringify(e, null, 2)}`,
-        ),
-      );
-    },
-  },
-};
-export const evaluatePredicates = (context, root) => {
-  const bindings = Map()
-    .set("global", context.global)
-    .set("root", root)
-    .set("local", root);
-  const traverse = (bindings, predicate, raw) => {
-    if (predicate.kind == "primitive") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        return ValueOrErrors.Default.return({
-          kind: "primitive",
-          value: result,
-        });
-      });
-    }
-    if (predicate.kind == "record") {
-      if (typeof raw != "object" || !("kind" in raw) || raw.kind != "record") {
-        return ValueOrErrors.Default.throwOne(
-          `parsing expected record in raw, got ${JSON.stringify(raw)}`,
-        );
-      }
-      return calculateVisibility(predicate.value, bindings).Then((result) =>
-        ValueOrErrors.Operations.All(
-          List(
-            predicate.fields.entrySeq().map(([fieldName, fieldPredicate]) => {
-              const fieldRaw = raw.fields.get(fieldName);
-              if (fieldRaw == undefined) {
-                return ValueOrErrors.Default.return([
-                  fieldName,
-                  { kind: "primitive", value: false },
-                ]);
-              }
-              if (fieldPredicate.kind == "record") {
-                const localBindings = bindings.get("local");
-                const fieldLocal = localBindings.fields.get(fieldName);
-                if (fieldLocal == undefined) {
-                  return ValueOrErrors.Default.throwOne(
-                    `Error: parsing cannot find field ${fieldName} in local ${JSON.stringify(localBindings)}`,
-                  );
-                }
-                const fieldBindings = bindings.set("local", fieldLocal);
-                return traverse(fieldBindings, fieldPredicate, fieldRaw).Then(
-                  (evaluation) =>
-                    ValueOrErrors.Default.return([fieldName, evaluation]),
-                );
-              }
-              return traverse(bindings, fieldPredicate, fieldRaw).Then(
-                (evaluation) =>
-                  ValueOrErrors.Default.return([fieldName, evaluation]),
-              );
-            }),
-          ),
-        ).Then((evaluations) => {
-          return ValueOrErrors.Default.return({
-            kind: "form",
-            value: result,
-            fields: Map(evaluations.map((_) => [_[0], _[1]])),
-          });
-        }),
-      );
-    }
-    if (predicate.kind == "list") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        if (PredicateValue.Operations.IsTuple(raw)) {
-          return ValueOrErrors.Operations.All(
-            List(
-              raw.values.map((value, index) => {
-                const elementLocal = raw.values.get(index);
-                if (elementLocal == undefined) {
-                  return ValueOrErrors.Default.throwOne(
-                    `Error: cannot find element of index ${index} in local ${JSON.stringify(raw)}`,
-                  );
-                }
-                const elementBindings = bindings.set("local", elementLocal);
-                return traverse(
-                  elementBindings,
-                  predicate.elementExpression,
-                  value,
-                );
-              }),
-            ),
-          ).Then((elementResults) => {
-            return ValueOrErrors.Default.return({
-              kind: "list",
-              value: result,
-              elementValues: elementResults.toArray(),
-            });
-          });
-        }
-        return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected tuple, got ${JSON.stringify(raw)}`,
-        );
-      });
-    }
-    if (predicate.kind == "map") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        if (typeof raw == "object" && "kind" in raw && raw.kind == "tuple") {
-          return ValueOrErrors.Operations.All(
-            List(
-              raw.values.map((kv) => {
-                if (PredicateValue.Operations.IsTuple(kv)) {
-                  const keyLocal = kv.values.get(0);
-                  const valueLocal = kv.values.get(1);
-                  if (keyLocal == undefined || valueLocal == undefined) {
-                    return ValueOrErrors.Default.throwOne(
-                      `Error: cannot find key or value of ${JSON.stringify(kv)} in local ${JSON.stringify(raw)}`,
-                    );
-                  }
-                  const keyBindings = bindings.set("local", keyLocal);
-                  const valueBindings = bindings.set("local", valueLocal);
-                  return traverse(
-                    keyBindings,
-                    predicate.keyExpression,
-                    keyLocal,
-                  ).Then((keyResult) => {
-                    return traverse(
-                      valueBindings,
-                      predicate.valueExpression,
-                      valueLocal,
-                    ).Then((valueResult) => {
-                      return ValueOrErrors.Default.return({
-                        key: keyResult,
-                        value: valueResult,
-                      });
-                    });
-                  });
-                }
-                return ValueOrErrors.Default.throwOne(
-                  `Error: parsing expected tuple of key and value, got ${JSON.stringify(kv)}`,
-                );
-              }),
-            ),
-          ).Then((keyValues) => {
-            return ValueOrErrors.Default.return({
-              kind: "map",
-              value: result,
-              elementValues: keyValues.toArray(),
-            });
-          });
-        }
-        return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected tuple of key value pairs, got ${JSON.stringify(raw)}`,
-        );
-      });
-    }
-    if (predicate.kind == "tuple") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        if (PredicateValue.Operations.IsTuple(raw)) {
-          return ValueOrErrors.Operations.All(
-            List(
-              raw.values.map((value, index) => {
-                const elementLocal = raw.values.get(index);
-                if (elementLocal == undefined) {
-                  return ValueOrErrors.Default.throwOne(
-                    `Error: cannot find element of index ${index} in local ${JSON.stringify(raw)}`,
-                  );
-                }
-                const elementBindings = bindings.set("local", elementLocal);
-                return traverse(
-                  elementBindings,
-                  predicate.elementExpressions[index],
-                  value,
-                );
-              }),
-            ),
-          ).Then((elementResults) => {
-            return ValueOrErrors.Default.return({
-              kind: "tuple",
-              value: result,
-              elementValues: elementResults.toArray(),
-            });
-          });
-        }
-        return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected tuple, got ${JSON.stringify(raw)}`,
-        );
-      });
-    }
-    if (predicate.kind == "sum") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        if (PredicateValue.Operations.IsSum(raw)) {
-          const local = raw.value.value;
-          const innerBindings = bindings.set("local", local);
-          return traverse(
-            innerBindings,
-            raw.value.kind === "l"
-              ? predicate.leftExpression
-              : predicate.rightExpression,
-            local,
-          ).Then((innerRes) => {
-            return ValueOrErrors.Default.return(
-              FormFieldPredicateEvaluation.Default.sum(result, innerRes),
-            );
-          });
-        }
-        return ValueOrErrors.Default.throwOne(
-          `Error: parsing expected sum, got ${JSON.stringify(raw)}`,
-        );
-      });
-    }
-    if (predicate.kind == "unit") {
-      return calculateVisibility(predicate.value, bindings).Then((result) => {
-        return ValueOrErrors.Default.return({
-          kind: "unit",
-          value: result,
-        });
-      });
-    }
-    return ValueOrErrors.Default.throwOne(
-      `Error: parsing unsupported predicate kind ${JSON.stringify(raw)}`,
-    );
-  };
-  const res = traverse(
-    bindings,
-    {
-      kind: "record",
-      value: true,
-      fields: context.visibilityPredicateExpressions,
-    },
-    root,
-  ).Then((visibilities) => {
-    return traverse(
-      bindings,
-      {
-        kind: "record",
-        value: true,
-        fields: context.disabledPredicatedExpressions,
-      },
-      root,
-    ).Then((disabledFields) => {
-      return ValueOrErrors.Default.return({
-        visiblityPredicateEvaluations: visibilities,
-        disabledPredicateEvaluations: disabledFields,
-      });
-    });
-  });
-  if (res.kind == "errors") {
-    console.error("error evaluating predicates", res);
-  }
-  return res;
-};
-//# sourceMappingURL=state.js.map