@rsconcept/domain 1.0.0 → 1.2.0

package/dist/rslang/eval/evaluator.js

@@ -1,1514 +1,607 @@
-// src/parsing/ast.ts
-var TOKEN_ERROR = 0;
-function getNodeText(node) {
-  if (node.data.dataType === "string" && typeof node.data.value === "string") {
-    return node.data.value;
-  }
-  return `NO DATA NODE: ${node.typeID}`;
-}
-function getNodeIndices(node) {
-  if (node.data.dataType === "string[]" && Array.isArray(node.data.value)) {
-    return node.data.value.map((s) => parseInt(s, 10)).filter((n) => !isNaN(n));
-  }
-  return [];
-}
-
-// src/rslang/ast-annotations.ts
-var AST_ERRORS_KEY = "rsErrors";
-function annotateError(node, code, params) {
-  if (typeof node.annotation === "object" && node.annotation !== null && AST_ERRORS_KEY in node.annotation && isAstNodeErrorRef(node.annotation[AST_ERRORS_KEY])) {
-    return;
-  }
-  const entry = params !== void 0 && params.length > 0 ? { code, params: [...params] } : { code };
-  node.annotation = {
-    ...typeof node.annotation === "object" && node.annotation !== null ? node.annotation : {},
-    [AST_ERRORS_KEY]: entry
-  };
-}
-function isAstNodeErrorRef(x) {
-  if (typeof x !== "object" || x === null || !("code" in x)) {
-    return false;
-  }
-  const code = x.code;
-  if (typeof code !== "number") {
-    return false;
-  }
-  if (!("params" in x)) {
-    return true;
-  }
-  const p = x.params;
-  if (p === void 0) {
-    return true;
-  }
-  return Array.isArray(p) && p.every((item) => typeof item === "string");
-}
-
-// src/rslang/error.ts
-var RSErrorCode = {
-  unknownSyntax: 33792,
-  // 33792
-  missingParenthesis: 33798,
-  // 33798
-  missingCurlyBrace: 33799,
-  // 33799
-  missingSquareBracket: 33800,
-  // 33800
-  bracketMismatch: 33801,
-  // 33801
-  doubleParenthesis: 33802,
-  // 33802
-  missingOpenBracket: 33803,
-  // 33803
-  expectedLocal: 33813,
-  // 33813
-  expectedType: 33814,
-  // 33814
-  localDoubleDeclare: 10241,
-  // 10241
-  localNotUsed: 10242,
-  // 10242
-  localUndeclared: 34817,
-  // 34817
-  localShadowing: 34818,
-  // 34818
-  typesNotEqual: 34819,
-  // 34819
-  globalNotTyped: 34820,
-  // 34820
-  invalidDecart: 34821,
-  // 34821
-  invalidBoolean: 34822,
-  // 34822
-  invalidTypeOperation: 34823,
-  // 34823
-  invalidCard: 34824,
-  // 34824
-  invalidDebool: 34825,
-  // 34825
-  globalFuncWithoutArgs: 34827,
-  // 34827
-  invalidReduce: 34832,
-  // 34832
-  invalidProjectionTuple: 34833,
-  // 34833
-  invalidProjectionSet: 34834,
-  // 34834
-  invalidEnumeration: 34835,
-  // 34835
-  invalidCortegeDeclare: 34836,
-  // 34836
-  localOutOfScope: 34837,
-  // 34837
-  invalidElementPredicate: 34838,
-  // 34838
-  invalidEmptySetUsage: 34839,
-  // 34839
-  invalidArgsArity: 34840,
-  // 34840
-  invalidArgumentType: 34841,
-  // 34841
-  globalStructure: 34844,
-  // 34844
-  radicalUsage: 34849,
-  // 34849
-  invalidFilterArgumentType: 34850,
-  // 34850
-  invalidFilterArity: 34851,
-  // 34851
-  arithmeticNotSupported: 34852,
-  // 34852
-  typesNotCompatible: 34853,
-  // 34853
-  orderingNotSupported: 34854,
-  // 34854
-  expectedLogic: 34855,
-  // 34855
-  expectedSetexpr: 34856,
-  // 34856
-  invalidArgumentCortegeDeclare: 34857,
-  // 34857
-  globalNoValue: 34880,
-  // 34880
-  invalidPropertyUsage: 34881,
-  // 34881
-  // Value evaluation (runtime)
-  calcUnknownError: 33024,
-  // 35328
-  setOverflow: 33025,
-  // 35329
-  booleanBaseLimit: 33026,
-  // 35330
-  calcGlobalMissing: 33027,
-  // 35331
-  iterationsLimit: 33028,
-  // 35332
-  calcInvalidDebool: 33029,
-  // 35333
-  iterateInfinity: 33030,
-  // 35334
-  calculationNotSupported: 33031,
-  // 35335
-  cstEmptyDerived: 34913,
-  // 34913
-  definitionNotAllowed: 34914
-  // 34914
-};
-
-// src/rslang/parser/token.ts
-var TokenID = {
-  // Global, local IDs and literals
-  ERROR: TOKEN_ERROR,
-  ID_LOCAL: 258,
-  ID_GLOBAL: 259,
-  ID_FUNCTION: 260,
-  ID_PREDICATE: 261,
-  ID_RADICAL: 262,
-  LIT_INTEGER: 263,
-  LIT_WHOLE_NUMBERS: 264,
-  LIT_EMPTYSET: 265,
-  // Arithmetic
-  PLUS: 266,
-  MINUS: 267,
-  MULTIPLY: 268,
-  // Integer predicate symbols
-  GREATER: 269,
-  LESSER: 270,
-  GREATER_OR_EQ: 271,
-  LESSER_OR_EQ: 272,
-  // Equality comparison
-  EQUAL: 273,
-  NOTEQUAL: 274,
-  // Logic predicate symbols
-  QUANTOR_UNIVERSAL: 275,
-  QUANTOR_EXISTS: 276,
-  LOGIC_NOT: 277,
-  LOGIC_EQUIVALENT: 278,
-  LOGIC_IMPLICATION: 279,
-  LOGIC_OR: 280,
-  LOGIC_AND: 281,
-  // Set theory predicate symbols
-  SET_IN: 282,
-  SET_NOT_IN: 283,
-  SUBSET: 284,
-  SUBSET_OR_EQ: 285,
-  NOT_SUBSET: 286,
-  // Set theory operators
-  DECART: 287,
-  SET_UNION: 288,
-  SET_INTERSECTION: 289,
-  SET_MINUS: 290,
-  SET_SYMMETRIC_MINUS: 291,
-  BOOLEAN: 292,
-  // Structure operations
-  BIGPR: 293,
-  SMALLPR: 294,
-  FILTER: 295,
-  CARD: 296,
-  BOOL: 297,
-  DEBOOL: 298,
-  REDUCE: 299,
-  // Term constructions prefixes
-  DECLARATIVE: 300,
-  RECURSIVE: 301,
-  IMPERATIVE: 302,
-  ITERATE: 303,
-  ASSIGN: 304,
-  // Punctuation
-  PUNCTUATION_DEFINE: 305,
-  PUNCTUATION_STRUCT: 306,
-  PUNCTUATION_PL: 307,
-  PUNCTUATION_PR: 308,
-  PUNCTUATION_CL: 309,
-  PUNCTUATION_CR: 310,
-  PUNCTUATION_SL: 311,
-  PUNCTUATION_SR: 312,
-  PUNCTUATION_BAR: 313,
-  PUNCTUATION_COMMA: 314,
-  PUNCTUATION_SEMICOLON: 315,
-  // ======= Non-terminal tokens =========
-  NT_ENUM_DECL: 316,
-  NT_TUPLE: 317,
-  NT_ENUMERATION: 318,
-  NT_TUPLE_DECL: 319,
-  NT_ARG_DECL: 320,
-  NT_FUNC_DEFINITION: 321,
-  NT_ARGUMENTS: 322,
-  NT_FUNC_CALL: 323,
-  NT_DECLARATIVE_EXPR: 324,
-  NT_IMPERATIVE_EXPR: 325,
-  NT_RECURSIVE_FULL: 326,
-  NT_RECURSIVE_SHORT: 327,
-  // ======= Helper tokens ========
-  INTERRUPT: 328,
-  END: 329
-};
-
-// src/rslang/eval/evaluation-cache.ts
-var EvaluationMetadata = class {
-  byNode = /* @__PURE__ */ new WeakMap();
-  get(node) {
-    let info = this.byNode.get(node);
-    if (!info) {
-      info = analyzeNode(node, /* @__PURE__ */ new Set());
-      this.byNode.set(node, info);
-    }
-    return info;
-  }
-};
-var EvaluationCache = class {
-  entries = /* @__PURE__ */ new Map();
-  /** Cache hits in the current evaluation run (for tests/diagnostics). */
-  hits = 0;
-  /** Returns cached value, or `undefined` on miss or stamp mismatch. */
-  lookup(structuralKey, stamp) {
-    const entry = this.entries.get(structuralKey);
-    if (entry?.stamp !== stamp) {
-      return void 0;
-    }
-    this.hits++;
-    return entry.value;
-  }
-  /** Stores one value per structural key (replaces previous stamp). */
-  store(structuralKey, stamp, value) {
-    this.entries.set(structuralKey, { stamp, value });
-  }
-  clear() {
-    this.entries.clear();
-    this.hits = 0;
-  }
-};
-function analyzeNode(node, bound) {
-  const reads = collectReads(node, bound);
-  const structuralKey = buildStructuralKey(node);
-  const cacheable = isCacheableNode(node);
-  return { reads, structuralKey, cacheable };
-}
-function isCacheableNode(node) {
-  switch (node.typeID) {
-    case TokenID.ASSIGN:
-    case TokenID.ITERATE:
-    case TokenID.NT_IMPERATIVE_EXPR:
-    case TokenID.NT_DECLARATIVE_EXPR:
-    case TokenID.NT_RECURSIVE_FULL:
-    case TokenID.NT_RECURSIVE_SHORT:
-    case TokenID.QUANTOR_UNIVERSAL:
-    case TokenID.QUANTOR_EXISTS:
-    case TokenID.LOGIC_AND:
-    case TokenID.LOGIC_OR:
-    case TokenID.LOGIC_IMPLICATION:
-    case TokenID.NT_FUNC_DEFINITION:
-    case TokenID.LIT_INTEGER:
-    case TokenID.LIT_EMPTYSET:
-    case TokenID.LIT_WHOLE_NUMBERS:
-    case TokenID.ID_LOCAL:
-    case TokenID.ID_RADICAL:
-    case TokenID.ID_GLOBAL:
-      return false;
-    default:
-      return !node.hasError;
-  }
-}
-function buildStructuralKey(node) {
-  switch (node.typeID) {
-    case TokenID.ID_GLOBAL:
-    case TokenID.ID_LOCAL:
-    case TokenID.ID_RADICAL:
-    case TokenID.LIT_INTEGER:
-    case TokenID.LIT_EMPTYSET:
-    case TokenID.LIT_WHOLE_NUMBERS:
-      return `${node.typeID}:${nodeTextKey(node)}`;
-    case TokenID.NT_FUNC_CALL:
-      return `${node.typeID}:${nodeTextKey(node.children[0])}(${node.children.slice(1).map(buildStructuralKey).join(",")})`;
-    case TokenID.BIGPR:
-    case TokenID.SMALLPR:
-    case TokenID.FILTER:
-      return `${node.typeID}:${indicesKey(node)}(${node.children.map(buildStructuralKey).join(",")})`;
-    default:
-      return `${node.typeID}(${node.children.map(buildStructuralKey).join(",")})`;
-  }
-}
-function nodeTextKey(node) {
-  if (node.data.dataType === "number") {
-    return String(node.data.value);
-  }
-  return getNodeText(node);
-}
-function indicesKey(node) {
-  return getNodeIndices(node).join(".");
-}
-function collectReads(node, bound) {
-  const reads = /* @__PURE__ */ new Set();
-  collectReadsImpl(node, bound, reads);
-  return reads;
-}
-function collectReadsImpl(node, bound, reads) {
-  switch (node.typeID) {
-    case TokenID.ID_LOCAL:
-    case TokenID.ID_RADICAL: {
-      reads.add(getNodeText(node));
-      return;
-    }
-    case TokenID.QUANTOR_UNIVERSAL:
-    case TokenID.QUANTOR_EXISTS: {
-      collectReadsImpl(node.children[1], bound, reads);
-      const innerBound = extendBound(bound, node.children[0]);
-      collectReadsImpl(node.children[2], innerBound, reads);
-      return;
-    }
-    case TokenID.NT_DECLARATIVE_EXPR: {
-      collectReadsImpl(node.children[1], bound, reads);
-      const innerBound = extendBound(bound, node.children[0]);
-      collectReadsImpl(node.children[2], innerBound, reads);
-      return;
-    }
-    case TokenID.ITERATE: {
-      collectReadsImpl(node.children[1], bound, reads);
-      return;
-    }
-    case TokenID.ASSIGN: {
-      collectReadsImpl(node.children[1], bound, reads);
-      return;
-    }
-    case TokenID.NT_IMPERATIVE_EXPR: {
-      const innerBound = new Set(bound);
-      collectReadsImpl(node.children[0], innerBound, reads);
-      for (let i = 1; i < node.children.length; i++) {
-        const child = node.children[i];
-        if (child.typeID === TokenID.ITERATE) {
-          extendBoundInPlace(innerBound, child.children[0]);
-          collectReadsImpl(child.children[1], innerBound, reads);
-        } else if (child.typeID === TokenID.ASSIGN) {
-          collectReadsImpl(child.children[1], innerBound, reads);
-          extendBoundInPlace(innerBound, child.children[0]);
-        } else {
-          collectReadsImpl(child, innerBound, reads);
-        }
-      }
-      return;
-    }
-    case TokenID.NT_RECURSIVE_FULL:
-    case TokenID.NT_RECURSIVE_SHORT: {
-      collectReadsImpl(node.children[1], bound, reads);
-      const innerBound = extendBound(bound, node.children[0]);
-      if (node.typeID === TokenID.NT_RECURSIVE_FULL) {
-        collectReadsImpl(node.children[2], innerBound, reads);
-        collectReadsImpl(node.children[3], innerBound, reads);
-      } else {
-        collectReadsImpl(node.children[2], innerBound, reads);
-      }
-      return;
-    }
-    case TokenID.NT_FUNC_DEFINITION: {
-      const innerBound = extendBound(bound, node.children[0]);
-      collectReadsImpl(node.children[1], innerBound, reads);
-      return;
-    }
-    case TokenID.NT_FUNC_CALL: {
-      for (let i = 1; i < node.children.length; i++) {
-        collectReadsImpl(node.children[i], bound, reads);
-      }
-      return;
-    }
-    case TokenID.LOGIC_AND:
-    case TokenID.LOGIC_OR:
-    case TokenID.LOGIC_IMPLICATION: {
-      collectReadsImpl(node.children[0], bound, reads);
-      collectReadsImpl(node.children[1], bound, reads);
-      return;
-    }
-    default:
-      for (const child of node.children) {
-        collectReadsImpl(child, bound, reads);
-      }
-  }
-}
-function extendBound(bound, declNode) {
-  const next = new Set(bound);
-  extendBoundInPlace(next, declNode);
-  return next;
-}
-function extendBoundInPlace(bound, declNode) {
-  switch (declNode.typeID) {
-    case TokenID.ID_LOCAL:
-    case TokenID.ID_RADICAL:
-      bound.add(getNodeText(declNode));
-      break;
-    case TokenID.NT_TUPLE_DECL:
-    case TokenID.NT_ENUM_DECL:
-      for (const child of declNode.children) {
-        extendBoundInPlace(bound, child);
-      }
-      break;
-    case TokenID.NT_ARG_DECL:
-      extendBoundInPlace(bound, declNode.children[0]);
-      break;
-  }
-}
-
-// src/rslang/semantic/typification.ts
-var TypeID = {
-  anyTypification: 1,
-  integer: 2,
-  basic: 3,
-  tuple: 4,
-  collection: 5,
-  logic: 6,
-  function: 7,
-  predicate: 8
-};
-var LogicT = { typeID: TypeID.logic };
-var IntegerT = {
-  typeID: TypeID.integer,
-  isOrdered: true,
-  isArithmetic: true,
-  isIntegerCompatible: true
-};
-var AnyTypificationT = { typeID: TypeID.anyTypification };
-var EmptySetT = bool(AnyTypificationT);
-function bool(base) {
-  return { typeID: TypeID.collection, base };
-}
-
-// src/rslang/eval/value-api.ts
-function cartesianProduct(factors) {
-  const cardinality = factors.reduce((acc, f) => acc * f.length, 1);
-  if (cardinality > SET_INFINITY) {
-    return null;
-  }
-  if (cardinality === 0 || factors.length === 0) {
-    return EmptySetV;
-  }
-  let accumulator = [[]];
-  for (const factor of factors) {
-    const next = [];
-    for (const prefix of accumulator) {
-      for (const value of factor) {
-        next.push([...prefix, value]);
-      }
-    }
-    accumulator = next;
-  }
-  return accumulator.map(tuple);
-}
-function boolean(base) {
-  if (base.length > BOOL_INFINITY) {
-    return null;
-  }
-  return powerset(base);
-}
-function powerset(arr) {
-  const result = [[]];
-  if (arr.length === 0) {
-    return result;
-  }
-  let current = [[]];
-  let maxIndex = [-1];
-  while (current.length > 0) {
-    const next = [];
-    const nextMaxIndex = [];
-    for (let i = 0; i < current.length; i++) {
-      for (let j = maxIndex[i] + 1; j < arr.length; j++) {
-        const subset = [...current[i], arr[j]];
-        result.push(subset);
-        if (j < arr.length - 1) {
-          next.push(subset);
-          nextMaxIndex.push(j);
-        }
-      }
-    }
-    current = next;
-    maxIndex = nextMaxIndex;
-  }
-  return result;
-}
-function contains(setData, element) {
-  let left = 0;
-  let right = setData.length - 1;
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    const cmp = compare(setData[mid], element);
-    if (cmp === 0) {
-      return true;
-    } else if (cmp < 0) {
-      left = mid + 1;
-    } else {
-      right = mid - 1;
-    }
-  }
-  return false;
-}
-function isSubsetOrEq(a, b) {
-  let i = 0, j = 0;
-  while (i < a.length && j < b.length) {
-    const cmp = compare(a[i], b[j]);
-    if (cmp === 0) {
-      i++;
-      j++;
-    } else if (cmp > 0) {
-      j++;
-    } else {
-      return false;
-    }
-  }
-  return i === a.length;
-}
-function reduce(target) {
-  const result = [];
-  for (const element of target) {
-    result.push(...element);
-  }
-  return set(result);
-}
-function setUnion(set1, set2) {
-  const result = [];
-  let i = 0, j = 0;
-  while (i < set1.length && j < set2.length) {
-    const cmp = compare(set1[i], set2[j]);
-    if (cmp < 0) {
-      result.push(set1[i]);
-      i++;
-    } else if (cmp > 0) {
-      result.push(set2[j]);
-      j++;
-    } else {
-      result.push(set1[i]);
-      i++;
-      j++;
-    }
-  }
-  while (i < set1.length) {
-    result.push(set1[i]);
-    i++;
-  }
-  while (j < set2.length) {
-    result.push(set2[j]);
-    j++;
-  }
-  return result;
-}
-function setIntersection(set1, set2) {
-  const result = [];
-  for (let i = 0, j = 0; i < set1.length && j < set2.length; ) {
-    const cmp = compare(set1[i], set2[j]);
-    if (cmp < 0) {
-      i++;
-    } else if (cmp > 0) {
-      j++;
-    } else {
-      result.push(set1[i]);
-      i++;
-      j++;
-    }
-  }
-  return result;
-}
-function setDiff(set1, set2) {
-  const result = [];
-  let i = 0, j = 0;
-  while (i < set1.length && j < set2.length) {
-    const cmp = compare(set1[i], set2[j]);
-    if (cmp < 0) {
-      result.push(set1[i]);
-      i++;
-    } else if (cmp > 0) {
-      j++;
-    } else {
-      i++;
-      j++;
-    }
-  }
-  while (i < set1.length) {
-    result.push(set1[i]);
-    i++;
-  }
-  return result;
-}
-function setSymDiff(set1, set2) {
-  const result = [];
-  let i = 0, j = 0;
-  while (i < set1.length && j < set2.length) {
-    const cmp = compare(set1[i], set2[j]);
-    if (cmp < 0) {
-      result.push(set1[i]);
-      i++;
-    } else if (cmp > 0) {
-      result.push(set2[j]);
-      j++;
-    } else {
-      i++;
-      j++;
-    }
-  }
-  while (i < set1.length) {
-    result.push(set1[i]);
-    i++;
-  }
-  while (j < set2.length) {
-    result.push(set2[j]);
-    j++;
-  }
-  return result;
-}
-function projection(target, indices) {
-  const projectedElements = target.map((element) => {
-    const newComponents = indices.map((idx) => element[idx]);
-    return indices.length === 1 ? newComponents[0] : tuple(newComponents);
-  });
-  return set(projectedElements);
-}
-function printValue(data) {
-  if (!Array.isArray(data)) {
-    return String(data);
-  }
-  const len = data.length;
-  if (data.length === 0) {
-    return "{}";
-  }
-  const isTuple = data[0] === TUPLE_ID;
-  const start = isTuple ? 1 : 0;
-  let result = isTuple ? "(" : "{";
-  for (let i = start; i < len; i++) {
-    if (i > start) result += ", ";
-    result += printValue(data[i]);
-  }
-  result += isTuple ? ")" : "}";
-  return result;
-}
-
-// src/rslang/eval/value.ts
-var TUPLE_ID = -111;
-var VALUE_TRUE = 1;
-var VALUE_FALSE = 0;
-var SET_INFINITY = 1e7;
-var BOOL_INFINITY = 18;
-var EmptySetV = [];
-function compare(v1, v2) {
-  const stack1 = [v1];
-  const stack2 = [v2];
-  while (stack1.length > 0 && stack2.length > 0) {
-    const el1 = stack1.pop();
-    const el2 = stack2.pop();
-    if (el1 === el2) {
-      continue;
-    }
-    const type1 = typeof el1;
-    const type2 = typeof el2;
-    if (type1 === "number" && type2 === "number") {
-      const numDiff = el1 - el2;
-      if (numDiff !== 0) return numDiff;
-      continue;
-    }
-    const isArray1 = Array.isArray(el1);
-    const isArray2 = Array.isArray(el2);
-    if (!isArray1 || !isArray2) {
-      throw new Error(`Cannot compare different types ${printValue(el1)} and ${printValue(el2)}`);
-    }
-    const arr1 = el1;
-    const arr2 = el2;
-    const len1 = arr1.length;
-    const len2 = arr2.length;
-    if (len1 !== len2) {
-      return len1 - len2;
-    }
-    for (let i = len1 - 1; i >= 0; i--) {
-      stack1.push(arr1[i]);
-      stack2.push(arr2[i]);
-    }
-  }
-  return 0;
-}
-function tuple(components) {
-  return [TUPLE_ID, ...components];
-}
-function set(elements) {
-  const sorted = [...elements].sort(compare);
-  for (let i = 1; i < sorted.length; ) {
-    if (compare(sorted[i - 1], sorted[i]) === 0) {
-      sorted.splice(i, 1);
-    } else {
-      i++;
-    }
-  }
-  return sorted;
-}
-
-// src/rslang/eval/evaluator.ts
-var MAX_ITERATIONS = 1e6;
-var TICK_PER_FUNCTION = 3;
-var TICK_PER_RECURSION = 3;
-var TICK_PER_IMPERATIVE = 1;
-var TICK_PER_DECLARATIVE = 1;
-var TICK_PER_QUANTIFIER = 1;
+import { annotateError } from "../ast-annotations.js";
+import { RSErrorCode } from "../error.js";
+import { getNodeIndices, getNodeText } from "../../parsing/ast.js";
+import "../../parsing/index.js";
+import { TokenID } from "../parser/token.js";
+import { EvaluationCache, EvaluationMetadata } from "./evaluation-cache.js";
+import { C as projection, E as setIntersection, O as setSymDiff, T as setDiff, c as compare, d as tuple, f as boolean, i as SET_INFINITY, k as setUnion, m as contains, n as EmptySetV, p as cartesianProduct, u as set, v as isSubsetOrEq, w as reduce } from "../../value-B8UtCqaK.js";
+//#region src/rslang/eval/evaluator.ts
+/**
+* Module: AST evaluation - visitor-pattern evaluator for RS expressions.
+*/
+/** Maximum iterations to prevent infinite loops (recursion, quantifiers, etc.). */
+const MAX_ITERATIONS = 1e6;
+const TICK_PER_FUNCTION = 3;
+const TICK_PER_RECURSION = 3;
+const TICK_PER_IMPERATIVE = 1;
+const TICK_PER_DECLARATIVE = 1;
+const TICK_PER_QUANTIFIER = 1;
+/** AST calculator - evaluates RS expressions via visitor pattern and provides updates via listeners.
+* Not safe for concurrent {@link run} calls on the same instance; use separate evaluators instead. */
 var Evaluator = class {
-  reporter;
-  annotateErrors = false;
-  disableCache = false;
-  locals = new LocalContext();
-  nodeMetadata = new EvaluationMetadata();
-  evalCache = new EvaluationCache();
-  callSiteStack = [];
-  context;
-  treeContext;
-  iterationCounter = 0;
-  /** Cache hits in the current evaluation run (for tests/diagnostics). */
-  get cacheHits() {
-    return this.evalCache.hits;
-  }
-  constructor(context, astContext) {
-    this.treeContext = astContext;
-    this.context = context;
-  }
-  run(ast, reporter, annotateErrors = false, disableCache = false) {
-    if (ast.hasError) {
-      return null;
-    }
-    this.reporter = reporter;
-    this.annotateErrors = annotateErrors;
-    this.disableCache = disableCache;
-    this.clear();
-    return this.dispatchVisit(ast);
-  }
-  clear() {
-    this.locals = new LocalContext();
-    this.evalCache.clear();
-    this.callSiteStack = [];
-    this.iterationCounter = 0;
-  }
-  errorNode(node) {
-    if (this.callSiteStack.length > 0) {
-      return this.callSiteStack[this.callSiteStack.length - 1];
-    }
-    return node;
-  }
-  onError(code, node, params) {
-    const target = this.errorNode(node);
-    this.reporter?.({ code, from: target.from, to: target.to, params });
-    if (this.annotateErrors) {
-      annotateError(target, code, params);
-    }
-    return null;
-  }
-  tick(node, counter = 1) {
-    this.iterationCounter += counter;
-    if (this.iterationCounter > MAX_ITERATIONS) {
-      this.onError(RSErrorCode.iterationsLimit, node, [String(MAX_ITERATIONS)]);
-      return false;
-    }
-    return true;
-  }
-  dispatchDeclare(node, value) {
-    switch (node.typeID) {
-      case TokenID.ID_LOCAL:
-        return this.declareLocal(node, value);
-      case TokenID.NT_TUPLE_DECL:
-        return this.declareTuple(node, value);
-      case TokenID.NT_ARG_DECL:
-        return this.dispatchDeclare(node.children[0], value);
-    }
-  }
-  declareLocal(node, value) {
-    const alias = getNodeText(node);
-    this.locals.setLocal(alias, value);
-  }
-  declareTuple(node, value) {
-    for (let child = 0; child < node.children.length; child++) {
-      this.dispatchDeclare(node.children[child], value[child + 1]);
-    }
-  }
-  dispatchVisit(node) {
-    const info = this.nodeMetadata.get(node);
-    let stamp = null;
-    if (info.cacheable && !this.disableCache) {
-      stamp = this.locals.buildDependencyStamp(info.reads);
-      if (stamp !== null) {
-        const cached = this.evalCache.lookup(info.structuralKey, stamp);
-        if (cached !== void 0) {
-          return cached;
-        }
-      }
-    }
-    const result = this.dispatchVisitImpl(node);
-    if (!this.disableCache && result !== null && info.cacheable && stamp !== null) {
-      this.evalCache.store(info.structuralKey, stamp, result);
-    }
-    return result;
-  }
-  dispatchVisitImpl(node) {
-    switch (node.typeID) {
-      case TokenID.ID_GLOBAL:
-        return this.visitGlobal(node);
-      case TokenID.NT_FUNC_CALL:
-        return this.visitFunctionCall(node);
-      case TokenID.ID_LOCAL:
-      case TokenID.ID_RADICAL:
-        return this.visitLocal(node);
-      case TokenID.LIT_INTEGER:
-        return this.visitInteger(node);
-      case TokenID.LIT_WHOLE_NUMBERS:
-        return this.onError(RSErrorCode.iterateInfinity, node);
-      case TokenID.LIT_EMPTYSET:
-        return EmptySetV;
-      case TokenID.PLUS:
-      case TokenID.MINUS:
-      case TokenID.MULTIPLY:
-        return this.visitArithmetic(node);
-      case TokenID.CARD:
-        return this.visitCard(node);
-      case TokenID.QUANTOR_UNIVERSAL:
-      case TokenID.QUANTOR_EXISTS:
-        return this.visitQuantifier(node);
-      case TokenID.LOGIC_NOT:
-        return this.visitNegation(node);
-      case TokenID.LOGIC_AND:
-      case TokenID.LOGIC_OR:
-      case TokenID.LOGIC_IMPLICATION:
-      case TokenID.LOGIC_EQUIVALENT:
-        return this.visitLogicBinary(node);
-      case TokenID.EQUAL:
-      case TokenID.NOTEQUAL:
-        return this.visitEquals(node);
-      case TokenID.GREATER:
-      case TokenID.LESSER:
-      case TokenID.GREATER_OR_EQ:
-      case TokenID.LESSER_OR_EQ:
-        return this.visitIntegerPredicate(node);
-      case TokenID.SET_IN:
-      case TokenID.SET_NOT_IN:
-      case TokenID.SUBSET:
-      case TokenID.SUBSET_OR_EQ:
-      case TokenID.NOT_SUBSET:
-        return this.visitSetexprPredicate(node);
-      case TokenID.DECART:
-        return this.visitDecart(node);
-      case TokenID.BOOLEAN:
-        return this.visitBoolean(node);
-      case TokenID.NT_TUPLE:
-        return this.visitTuple(node);
-      case TokenID.NT_ENUMERATION:
-        return this.visitEnumeration(node);
-      case TokenID.BOOL:
-        return this.visitBool(node);
-      case TokenID.DEBOOL:
-        return this.visitDebool(node);
-      case TokenID.SET_UNION:
-      case TokenID.SET_INTERSECTION:
-      case TokenID.SET_MINUS:
-      case TokenID.SET_SYMMETRIC_MINUS:
-        return this.visitSetexprBinary(node);
-      case TokenID.BIGPR:
-        return this.visitProjectSet(node);
-      case TokenID.SMALLPR:
-        return this.visitProjectTuple(node);
-      case TokenID.FILTER:
-        return this.visitFilter(node);
-      case TokenID.REDUCE:
-        return this.visitReduce(node);
-      case TokenID.NT_DECLARATIVE_EXPR:
-        return this.visitDeclarative(node);
-      case TokenID.NT_IMPERATIVE_EXPR:
-        return this.visitImperative(node);
-      case TokenID.ASSIGN:
-        return this.visitAssign(node);
-      case TokenID.NT_RECURSIVE_FULL:
-      case TokenID.NT_RECURSIVE_SHORT:
-        return this.visitRecursion(node);
-      case TokenID.NT_FUNC_DEFINITION:
-        return this.onError(RSErrorCode.calculationNotSupported, node);
-    }
-    return null;
-  }
-  visitChild(node, index) {
-    return this.dispatchVisit(node.children[index]);
-  }
-  visitGlobal(node) {
-    const alias = getNodeText(node);
-    const value = this.context.get(alias);
-    if (value === void 0) {
-      return this.onError(RSErrorCode.calcGlobalMissing, node, [alias]);
-    }
-    return value;
-  }
-  visitLocal(node) {
-    const alias = getNodeText(node);
-    return this.locals.getLocal(alias);
-  }
-  visitFunctionCall(node) {
-    const funcName = getNodeText(node.children[0]);
-    const ast = this.treeContext.get(funcName);
-    if (!ast) {
-      return this.onError(RSErrorCode.calcGlobalMissing, node.children[0], [funcName]);
-    }
-    if (!this.tick(node, TICK_PER_FUNCTION)) {
-      return null;
-    }
-    const args = [];
-    for (let i = 1; i < node.children.length; i++) {
-      const arg = this.visitChild(node, i);
-      if (arg === null) {
-        return null;
-      }
-      args.push(arg);
-    }
-    this.locals.startScope();
-    for (let i = 0; i < args.length; i++) {
-      this.dispatchDeclare(ast.children[0].children[i], args[i]);
-    }
-    this.callSiteStack.push(node);
-    let result;
-    try {
-      result = this.visitChild(ast, 1);
-    } finally {
-      this.callSiteStack.pop();
-    }
-    this.locals.endScope();
-    return result;
-  }
-  visitInteger(node) {
-    const value = node.data.dataType === "number" ? node.data.value : Number(node.data.value);
-    return Math.floor(value);
-  }
-  visitArithmetic(node) {
-    const v1 = this.visitChild(node, 0);
-    const v2 = this.visitChild(node, 1);
-    if (v1 === null || v2 === null) {
-      return null;
-    }
-    const a = v1;
-    const b = v2;
-    switch (node.typeID) {
-      case TokenID.PLUS:
-        return a + b;
-      case TokenID.MINUS:
-        return a - b;
-      case TokenID.MULTIPLY:
-        return a * b;
-    }
-    return null;
-  }
-  visitCard(node) {
-    const base = this.visitChild(node, 0);
-    if (base === null || !Array.isArray(base)) {
-      return null;
-    }
-    return base.length;
-  }
-  visitQuantifier(node) {
-    const domain = this.visitChild(node, 1);
-    if (domain === null) {
-      return null;
-    }
-    const isUniversal = node.typeID === TokenID.QUANTOR_UNIVERSAL;
-    if (domain.length === 0) {
-      return isUniversal ? VALUE_TRUE : VALUE_FALSE;
-    }
-    const varNodes = node.children[0].typeID === TokenID.NT_ENUM_DECL ? node.children[0].children : [node.children[0]];
-    const count = domain.length;
-    const iterators = [];
-    for (const declaration of varNodes) {
-      iterators.push(0);
-      this.dispatchDeclare(declaration, domain[0]);
-    }
-    let finishIteration = false;
-    while (!finishIteration) {
-      const iterationValue = this.visitChild(node, 2);
-      if (iterationValue === null) {
-        return null;
-      }
-      if (iterationValue === VALUE_TRUE !== isUniversal) {
-        return !isUniversal ? VALUE_TRUE : VALUE_FALSE;
-      }
-      let incrementIndex = iterators.length - 1;
-      while (true) {
-        if (iterators[incrementIndex] < count - 1) {
-          iterators[incrementIndex]++;
-          if (!this.tick(node, TICK_PER_QUANTIFIER)) {
-            return null;
-          }
-          this.dispatchDeclare(varNodes[incrementIndex], domain[iterators[incrementIndex]]);
-          incrementIndex = iterators.length - 1;
-          break;
-        } else if (incrementIndex === 0) {
-          finishIteration = true;
-          break;
-        } else {
-          iterators[incrementIndex] = 0;
-          this.dispatchDeclare(varNodes[incrementIndex], domain[0]);
-          incrementIndex--;
-        }
-      }
-    }
-    return isUniversal ? VALUE_TRUE : VALUE_FALSE;
-  }
-  visitNegation(node) {
-    const value = this.visitChild(node, 0);
-    if (value === null) {
-      return null;
-    }
-    return value === VALUE_TRUE ? VALUE_FALSE : VALUE_TRUE;
-  }
-  tryEvaluateFromFirstArg(op, first) {
-    if (op === TokenID.LOGIC_AND && !first || op === TokenID.LOGIC_OR && first) {
-      return first ? VALUE_TRUE : VALUE_FALSE;
-    }
-    if (op === TokenID.LOGIC_IMPLICATION && !first) {
-      return VALUE_TRUE;
-    }
-    return null;
-  }
-  visitLogicBinary(node) {
-    const v1 = this.visitChild(node, 0);
-    if (v1 === null) {
-      return null;
-    }
-    const b1 = v1 === VALUE_TRUE;
-    const attempt = this.tryEvaluateFromFirstArg(node.typeID, b1);
-    if (attempt !== null) {
-      return attempt;
-    }
-    const v2 = this.visitChild(node, 1);
-    if (v2 === null) {
-      return null;
-    }
-    const b2 = v2 === VALUE_TRUE;
-    let result;
-    switch (node.typeID) {
-      case TokenID.LOGIC_AND:
-        result = b1 && b2;
-        break;
-      case TokenID.LOGIC_OR:
-        result = b1 || b2;
-        break;
-      case TokenID.LOGIC_IMPLICATION:
-        result = !b1 || b2;
-        break;
-      case TokenID.LOGIC_EQUIVALENT:
-        result = b1 === b2;
-        break;
-      default:
-        return null;
-    }
-    return result ? VALUE_TRUE : VALUE_FALSE;
-  }
-  visitEquals(node) {
-    const v1 = this.visitChild(node, 0);
-    if (v1 === null) {
-      return null;
-    }
-    const v2 = this.visitChild(node, 1);
-    if (v2 === null) {
-      return null;
-    }
-    const areEqual = compare(v1, v2) === 0;
-    return areEqual === (node.typeID !== TokenID.NOTEQUAL) ? VALUE_TRUE : VALUE_FALSE;
-  }
-  visitIntegerPredicate(node) {
-    const v1 = this.visitChild(node, 0);
-    if (v1 === null) {
-      return null;
-    }
-    const v2 = this.visitChild(node, 1);
-    if (v2 === null) {
-      return null;
-    }
-    const a = v1;
-    const b = v2;
-    let result;
-    switch (node.typeID) {
-      case TokenID.GREATER:
-        result = a > b;
-        break;
-      case TokenID.LESSER:
-        result = a < b;
-        break;
-      case TokenID.GREATER_OR_EQ:
-        result = a >= b;
-        break;
-      case TokenID.LESSER_OR_EQ:
-        result = a <= b;
-        break;
-      default:
-        return null;
-    }
-    return result ? VALUE_TRUE : VALUE_FALSE;
-  }
-  visitSetexprPredicate(node) {
-    const v1 = this.visitChild(node, 0);
-    if (v1 === null) {
-      return null;
-    }
-    const v2 = this.visitChild(node, 1);
-    if (v2 === null) {
-      return null;
-    }
-    let result;
-    switch (node.typeID) {
-      case TokenID.SET_IN:
-        result = contains(v2, v1);
-        break;
-      case TokenID.SET_NOT_IN:
-        result = !contains(v2, v1);
-        break;
-      case TokenID.SUBSET:
-        result = compare(v1, v2) !== 0 && isSubsetOrEq(v1, v2);
-        break;
-      case TokenID.NOT_SUBSET:
-        result = compare(v1, v2) === 0 || !isSubsetOrEq(v1, v2);
-        break;
-      case TokenID.SUBSET_OR_EQ:
-        result = isSubsetOrEq(v1, v2);
-        break;
-      default:
-        return null;
-    }
-    return result ? VALUE_TRUE : VALUE_FALSE;
-  }
-  visitDecart(node) {
-    const args = [];
-    for (let i = 0; i < node.children.length; i++) {
-      const component = this.visitChild(node, i);
-      if (component === null) {
-        return null;
-      }
-      if (component.length === 0) {
-        return EmptySetV;
-      }
-      args.push(component);
-    }
-    const result = cartesianProduct(args);
-    if (result === null) {
-      this.onError(RSErrorCode.setOverflow, node, [String(SET_INFINITY)]);
-      return null;
-    }
-    return result;
-  }
-  visitBoolean(node) {
-    const base = this.visitChild(node, 0);
-    if (base === null) {
-      return null;
-    }
-    const result = boolean(base);
-    if (result === null) {
-      this.onError(RSErrorCode.booleanBaseLimit, node.children[0], [String(BOOL_INFINITY)]);
-      return null;
-    }
-    return result;
-  }
-  visitTuple(node) {
-    const args = [];
-    for (let i = 0; i < node.children.length; i++) {
-      const component = this.visitChild(node, i);
-      if (component === null) {
-        return null;
-      }
-      args.push(component);
-    }
-    return tuple(args);
-  }
-  visitEnumeration(node) {
-    const args = [];
-    for (let i = 0; i < node.children.length; i++) {
-      const element = this.visitChild(node, i);
-      if (element === null) {
-        return null;
-      }
-      args.push(element);
-    }
-    return set(args);
-  }
-  visitBool(node) {
-    const element = this.visitChild(node, 0);
-    if (element === null) {
-      return null;
-    }
-    return [element];
-  }
-  visitDebool(node) {
-    const target = this.visitChild(node, 0);
-    if (target === null) {
-      return null;
-    }
-    if (target.length !== 1) {
-      return this.onError(RSErrorCode.calcInvalidDebool, node.children[0]);
-    }
-    return target[0];
-  }
-  visitSetexprBinary(node) {
-    const v1 = this.visitChild(node, 0);
-    if (v1 === null) {
-      return null;
-    }
-    const v2 = this.visitChild(node, 1);
-    if (v2 === null) {
-      return null;
-    }
-    switch (node.typeID) {
-      case TokenID.SET_UNION:
-        return setUnion(v1, v2);
-      case TokenID.SET_INTERSECTION:
-        return setIntersection(v1, v2);
-      case TokenID.SET_MINUS:
-        return setDiff(v1, v2);
-      case TokenID.SET_SYMMETRIC_MINUS:
-        return setSymDiff(v1, v2);
-    }
-    return null;
-  }
-  visitProjectSet(node) {
-    const target = this.visitChild(node, 0);
-    if (target === null) {
-      return null;
-    }
-    const indices = getNodeIndices(node);
-    return projection(target, indices);
-  }
-  visitProjectTuple(node) {
-    const target = this.visitChild(node, 0);
-    if (target === null) {
-      return null;
-    }
-    const indices = getNodeIndices(node);
-    const components = indices.map((i) => target[i]);
-    return components.length === 1 ? components[0] : tuple(components);
-  }
-  visitFilter(node) {
-    const lastIdx = node.children.length - 1;
-    const argVal = this.visitChild(node, lastIdx);
-    if (argVal === null) {
-      return null;
-    }
-    if (argVal.length === 0) {
-      return EmptySetV;
-    }
-    const indices = getNodeIndices(node);
-    const tupleParam = indices.length === lastIdx;
-    if (tupleParam) {
-      const params = [];
-      for (let i = 0; i < lastIdx; i++) {
-        const param = this.visitChild(node, i);
-        if (param === null) {
-          return null;
-        }
-        if (param.length === 0) {
-          return EmptySetV;
-        }
-        params.push(param);
-      }
-      const result = [];
-      for (const element of argVal) {
-        let valid = true;
-        for (let j = 0; j < indices.length; j++) {
-          const comp = element[indices[j]];
-          const paramSet = params[j];
-          if (!contains(paramSet, comp)) {
-            valid = false;
-            break;
-          }
-        }
-        if (valid) {
-          result.push(element);
-        }
-      }
-      return result;
-    } else {
-      const paramVal = this.visitChild(node, 0);
-      if (paramVal === null) {
-        return null;
-      }
-      if (paramVal.length === 0) {
-        return EmptySetV;
-      }
-      const result = [];
-      for (const element of argVal) {
-        const comps = indices.map((i) => element[i]);
-        const testElement = comps.length === 1 ? comps[0] : tuple(comps);
-        if (contains(paramVal, testElement)) result.push(element);
-      }
-      return result;
-    }
-  }
-  visitReduce(node) {
-    const target = this.visitChild(node, 0);
-    if (target === null) {
-      return null;
-    }
-    return reduce(target);
-  }
-  visitDeclarative(node) {
-    const domain = this.visitChild(node, 1);
-    if (domain === null) {
-      return null;
-    }
-    const elements = [];
-    for (const element of domain) {
-      if (!this.tick(node, TICK_PER_DECLARATIVE)) {
-        return null;
-      }
-      this.dispatchDeclare(node.children[0], element);
-      const value = this.visitChild(node, 2);
-      if (value === null) {
-        return null;
-      }
-      if (value === VALUE_TRUE) {
-        elements.push(element);
-      }
-    }
-    return elements.length === 0 ? EmptySetV : elements;
-  }
-  visitImperative(node) {
-    const result = [];
-    const frames = [];
-    let currentChild = 1;
-    const advanceIterator = () => {
-      while (frames.length > 0) {
-        const top = frames[frames.length - 1];
-        if (top.valueID < top.domain.length - 1) {
-          top.valueID++;
-          const nextValue = top.domain[top.valueID];
-          if (!this.tick(node.children[top.childID], TICK_PER_IMPERATIVE)) {
-            return false;
-          }
-          this.dispatchDeclare(node.children[top.childID].children[0], nextValue);
-          currentChild = top.childID + 1;
-          return true;
-        }
-        frames.pop();
-      }
-      return false;
-    };
-    while (true) {
-      if (currentChild >= node.children.length) {
-        const element = this.visitChild(node, 0);
-        if (element === null) {
-          return null;
-        }
-        result.push(element);
-        if (!advanceIterator()) {
-          break;
-        }
-        continue;
-      }
-      const child = node.children[currentChild];
-      if (child.typeID === TokenID.ITERATE) {
-        const domain = this.visitChild(child, 1);
-        if (domain === null) {
-          return null;
-        }
-        if (domain.length === 0) {
-          if (!advanceIterator()) {
-            break;
-          }
-          continue;
-        }
-        if (!this.tick(child, TICK_PER_IMPERATIVE)) {
-          return null;
-        }
-        frames.push({
-          childID: currentChild,
-          domain,
-          valueID: 0
-        });
-        this.dispatchDeclare(child.children[0], domain[0]);
-        currentChild++;
-        continue;
-      }
-      const value = this.dispatchVisit(child);
-      if (value === null) {
-        return null;
-      }
-      if (value === VALUE_FALSE) {
-        if (!advanceIterator()) {
-          break;
-        }
-        continue;
-      }
-      currentChild++;
-    }
-    return set(result);
-  }
-  visitAssign(node) {
-    const value = this.visitChild(node, 1);
-    if (value === null) {
-      return null;
-    }
-    this.dispatchDeclare(node.children[0], value);
-    return VALUE_TRUE;
-  }
-  visitRecursion(node) {
-    const initialValue = this.visitChild(node, 1);
-    if (initialValue === null) {
-      return null;
-    }
-    const bodyIndex = node.typeID === TokenID.NT_RECURSIVE_FULL ? 3 : 2;
-    let current = initialValue;
-    while (true) {
-      if (!this.tick(node, TICK_PER_RECURSION)) {
-        return null;
-      }
-      this.dispatchDeclare(node.children[0], current);
-      if (node.typeID === TokenID.NT_RECURSIVE_FULL) {
-        const pred = this.visitChild(node, 2);
-        if (pred === null) {
-          return null;
-        }
-        if (pred !== VALUE_TRUE) {
-          break;
-        }
-      }
-      const next = this.visitChild(node, bodyIndex);
-      if (next === null) {
-        return null;
-      }
-      if (compare(current, next) === 0) {
-        break;
-      }
-      current = next;
-    }
-    return current;
-  }
+	reporter;
+	annotateErrors = false;
+	disableCache = false;
+	locals = new LocalContext();
+	nodeMetadata = new EvaluationMetadata();
+	evalCache = new EvaluationCache();
+	callSiteStack = [];
+	context;
+	treeContext;
+	iterationCounter = 0;
+	/** Cache hits in the current evaluation run (for tests/diagnostics). */
+	get cacheHits() {
+		return this.evalCache.hits;
+	}
+	constructor(context, astContext) {
+		this.treeContext = astContext;
+		this.context = context;
+	}
+	run(ast, reporter, annotateErrors = false, disableCache = false) {
+		if (ast.hasError) return null;
+		this.reporter = reporter;
+		this.annotateErrors = annotateErrors;
+		this.disableCache = disableCache;
+		this.clear();
+		return this.dispatchVisit(ast);
+	}
+	clear() {
+		this.locals = new LocalContext();
+		this.evalCache.clear();
+		this.callSiteStack = [];
+		this.iterationCounter = 0;
+	}
+	errorNode(node) {
+		if (this.callSiteStack.length > 0) return this.callSiteStack[this.callSiteStack.length - 1];
+		return node;
+	}
+	onError(code, node, params) {
+		const target = this.errorNode(node);
+		this.reporter?.({
+			code,
+			from: target.from,
+			to: target.to,
+			params
+		});
+		if (this.annotateErrors) annotateError(target, code, params);
+		return null;
+	}
+	tick(node, counter = 1) {
+		this.iterationCounter += counter;
+		if (this.iterationCounter > MAX_ITERATIONS) {
+			this.onError(RSErrorCode.iterationsLimit, node, [String(MAX_ITERATIONS)]);
+			return false;
+		}
+		return true;
+	}
+	dispatchDeclare(node, value) {
+		switch (node.typeID) {
+			case TokenID.ID_LOCAL: return this.declareLocal(node, value);
+			case TokenID.NT_TUPLE_DECL: return this.declareTuple(node, value);
+			case TokenID.NT_ARG_DECL: return this.dispatchDeclare(node.children[0], value);
+		}
+	}
+	declareLocal(node, value) {
+		const alias = getNodeText(node);
+		this.locals.setLocal(alias, value);
+	}
+	declareTuple(node, value) {
+		for (let child = 0; child < node.children.length; child++) this.dispatchDeclare(node.children[child], value[child + 1]);
+	}
+	dispatchVisit(node) {
+		const info = this.nodeMetadata.get(node);
+		let stamp = null;
+		if (info.cacheable && !this.disableCache) {
+			stamp = this.locals.buildDependencyStamp(info.reads);
+			if (stamp !== null) {
+				const cached = this.evalCache.lookup(info.structuralKey, stamp);
+				if (cached !== void 0) return cached;
+			}
+		}
+		const result = this.dispatchVisitImpl(node);
+		if (!this.disableCache && result !== null && info.cacheable && stamp !== null) this.evalCache.store(info.structuralKey, stamp, result);
+		return result;
+	}
+	dispatchVisitImpl(node) {
+		switch (node.typeID) {
+			case TokenID.ID_GLOBAL: return this.visitGlobal(node);
+			case TokenID.NT_FUNC_CALL: return this.visitFunctionCall(node);
+			case TokenID.ID_LOCAL:
+			case TokenID.ID_RADICAL: return this.visitLocal(node);
+			case TokenID.LIT_INTEGER: return this.visitInteger(node);
+			case TokenID.LIT_WHOLE_NUMBERS: return this.onError(RSErrorCode.iterateInfinity, node);
+			case TokenID.LIT_EMPTYSET: return EmptySetV;
+			case TokenID.PLUS:
+			case TokenID.MINUS:
+			case TokenID.MULTIPLY: return this.visitArithmetic(node);
+			case TokenID.CARD: return this.visitCard(node);
+			case TokenID.QUANTOR_UNIVERSAL:
+			case TokenID.QUANTOR_EXISTS: return this.visitQuantifier(node);
+			case TokenID.LOGIC_NOT: return this.visitNegation(node);
+			case TokenID.LOGIC_AND:
+			case TokenID.LOGIC_OR:
+			case TokenID.LOGIC_IMPLICATION:
+			case TokenID.LOGIC_EQUIVALENT: return this.visitLogicBinary(node);
+			case TokenID.EQUAL:
+			case TokenID.NOTEQUAL: return this.visitEquals(node);
+			case TokenID.GREATER:
+			case TokenID.LESSER:
+			case TokenID.GREATER_OR_EQ:
+			case TokenID.LESSER_OR_EQ: return this.visitIntegerPredicate(node);
+			case TokenID.SET_IN:
+			case TokenID.SET_NOT_IN:
+			case TokenID.SUBSET:
+			case TokenID.SUBSET_OR_EQ:
+			case TokenID.NOT_SUBSET: return this.visitSetexprPredicate(node);
+			case TokenID.DECART: return this.visitDecart(node);
+			case TokenID.BOOLEAN: return this.visitBoolean(node);
+			case TokenID.NT_TUPLE: return this.visitTuple(node);
+			case TokenID.NT_ENUMERATION: return this.visitEnumeration(node);
+			case TokenID.BOOL: return this.visitBool(node);
+			case TokenID.DEBOOL: return this.visitDebool(node);
+			case TokenID.SET_UNION:
+			case TokenID.SET_INTERSECTION:
+			case TokenID.SET_MINUS:
+			case TokenID.SET_SYMMETRIC_MINUS: return this.visitSetexprBinary(node);
+			case TokenID.BIGPR: return this.visitProjectSet(node);
+			case TokenID.SMALLPR: return this.visitProjectTuple(node);
+			case TokenID.FILTER: return this.visitFilter(node);
+			case TokenID.REDUCE: return this.visitReduce(node);
+			case TokenID.NT_DECLARATIVE_EXPR: return this.visitDeclarative(node);
+			case TokenID.NT_IMPERATIVE_EXPR: return this.visitImperative(node);
+			case TokenID.ASSIGN: return this.visitAssign(node);
+			case TokenID.NT_RECURSIVE_FULL:
+			case TokenID.NT_RECURSIVE_SHORT: return this.visitRecursion(node);
+			case TokenID.NT_FUNC_DEFINITION: return this.onError(RSErrorCode.calculationNotSupported, node);
+		}
+		return null;
+	}
+	visitChild(node, index) {
+		return this.dispatchVisit(node.children[index]);
+	}
+	visitGlobal(node) {
+		const alias = getNodeText(node);
+		const value = this.context.get(alias);
+		if (value === void 0) return this.onError(RSErrorCode.calcGlobalMissing, node, [alias]);
+		return value;
+	}
+	visitLocal(node) {
+		const alias = getNodeText(node);
+		return this.locals.getLocal(alias);
+	}
+	visitFunctionCall(node) {
+		const funcName = getNodeText(node.children[0]);
+		const ast = this.treeContext.get(funcName);
+		if (!ast) return this.onError(RSErrorCode.calcGlobalMissing, node.children[0], [funcName]);
+		if (!this.tick(node, TICK_PER_FUNCTION)) return null;
+		const args = [];
+		for (let i = 1; i < node.children.length; i++) {
+			const arg = this.visitChild(node, i);
+			if (arg === null) return null;
+			args.push(arg);
+		}
+		this.locals.startScope();
+		for (let i = 0; i < args.length; i++) this.dispatchDeclare(ast.children[0].children[i], args[i]);
+		this.callSiteStack.push(node);
+		let result;
+		try {
+			result = this.visitChild(ast, 1);
+		} finally {
+			this.callSiteStack.pop();
+		}
+		this.locals.endScope();
+		return result;
+	}
+	visitInteger(node) {
+		const value = node.data.dataType === "number" ? node.data.value : Number(node.data.value);
+		return Math.floor(value);
+	}
+	visitArithmetic(node) {
+		const v1 = this.visitChild(node, 0);
+		const v2 = this.visitChild(node, 1);
+		if (v1 === null || v2 === null) return null;
+		const a = v1;
+		const b = v2;
+		switch (node.typeID) {
+			case TokenID.PLUS: return a + b;
+			case TokenID.MINUS: return a - b;
+			case TokenID.MULTIPLY: return a * b;
+		}
+		return null;
+	}
+	visitCard(node) {
+		const base = this.visitChild(node, 0);
+		if (base === null || !Array.isArray(base)) return null;
+		return base.length;
+	}
+	visitQuantifier(node) {
+		const domain = this.visitChild(node, 1);
+		if (domain === null) return null;
+		const isUniversal = node.typeID === TokenID.QUANTOR_UNIVERSAL;
+		if (domain.length === 0) return isUniversal ? 1 : 0;
+		const varNodes = node.children[0].typeID === TokenID.NT_ENUM_DECL ? node.children[0].children : [node.children[0]];
+		const count = domain.length;
+		const iterators = [];
+		for (const declaration of varNodes) {
+			iterators.push(0);
+			this.dispatchDeclare(declaration, domain[0]);
+		}
+		let finishIteration = false;
+		while (!finishIteration) {
+			const iterationValue = this.visitChild(node, 2);
+			if (iterationValue === null) return null;
+			if (iterationValue === 1 !== isUniversal) return !isUniversal ? 1 : 0;
+			let incrementIndex = iterators.length - 1;
+			while (true) if (iterators[incrementIndex] < count - 1) {
+				iterators[incrementIndex]++;
+				if (!this.tick(node, TICK_PER_QUANTIFIER)) return null;
+				this.dispatchDeclare(varNodes[incrementIndex], domain[iterators[incrementIndex]]);
+				incrementIndex = iterators.length - 1;
+				break;
+			} else if (incrementIndex === 0) {
+				finishIteration = true;
+				break;
+			} else {
+				iterators[incrementIndex] = 0;
+				this.dispatchDeclare(varNodes[incrementIndex], domain[0]);
+				incrementIndex--;
+			}
+		}
+		return isUniversal ? 1 : 0;
+	}
+	visitNegation(node) {
+		const value = this.visitChild(node, 0);
+		if (value === null) return null;
+		return value === 1 ? 0 : 1;
+	}
+	tryEvaluateFromFirstArg(op, first) {
+		if (op === TokenID.LOGIC_AND && !first || op === TokenID.LOGIC_OR && first) return first ? 1 : 0;
+		if (op === TokenID.LOGIC_IMPLICATION && !first) return 1;
+		return null;
+	}
+	visitLogicBinary(node) {
+		const v1 = this.visitChild(node, 0);
+		if (v1 === null) return null;
+		const b1 = v1 === 1;
+		const attempt = this.tryEvaluateFromFirstArg(node.typeID, b1);
+		if (attempt !== null) return attempt;
+		const v2 = this.visitChild(node, 1);
+		if (v2 === null) return null;
+		const b2 = v2 === 1;
+		let result;
+		switch (node.typeID) {
+			case TokenID.LOGIC_AND:
+				result = b1 && b2;
+				break;
+			case TokenID.LOGIC_OR:
+				result = b1 || b2;
+				break;
+			case TokenID.LOGIC_IMPLICATION:
+				result = !b1 || b2;
+				break;
+			case TokenID.LOGIC_EQUIVALENT:
+				result = b1 === b2;
+				break;
+			default: return null;
+		}
+		return result ? 1 : 0;
+	}
+	visitEquals(node) {
+		const v1 = this.visitChild(node, 0);
+		if (v1 === null) return null;
+		const v2 = this.visitChild(node, 1);
+		if (v2 === null) return null;
+		return compare(v1, v2) === 0 === (node.typeID !== TokenID.NOTEQUAL) ? 1 : 0;
+	}
+	visitIntegerPredicate(node) {
+		const v1 = this.visitChild(node, 0);
+		if (v1 === null) return null;
+		const v2 = this.visitChild(node, 1);
+		if (v2 === null) return null;
+		const a = v1;
+		const b = v2;
+		let result;
+		switch (node.typeID) {
+			case TokenID.GREATER:
+				result = a > b;
+				break;
+			case TokenID.LESSER:
+				result = a < b;
+				break;
+			case TokenID.GREATER_OR_EQ:
+				result = a >= b;
+				break;
+			case TokenID.LESSER_OR_EQ:
+				result = a <= b;
+				break;
+			default: return null;
+		}
+		return result ? 1 : 0;
+	}
+	visitSetexprPredicate(node) {
+		const v1 = this.visitChild(node, 0);
+		if (v1 === null) return null;
+		const v2 = this.visitChild(node, 1);
+		if (v2 === null) return null;
+		let result;
+		switch (node.typeID) {
+			case TokenID.SET_IN:
+				result = contains(v2, v1);
+				break;
+			case TokenID.SET_NOT_IN:
+				result = !contains(v2, v1);
+				break;
+			case TokenID.SUBSET:
+				result = compare(v1, v2) !== 0 && isSubsetOrEq(v1, v2);
+				break;
+			case TokenID.NOT_SUBSET:
+				result = compare(v1, v2) === 0 || !isSubsetOrEq(v1, v2);
+				break;
+			case TokenID.SUBSET_OR_EQ:
+				result = isSubsetOrEq(v1, v2);
+				break;
+			default: return null;
+		}
+		return result ? 1 : 0;
+	}
+	visitDecart(node) {
+		const args = [];
+		for (let i = 0; i < node.children.length; i++) {
+			const component = this.visitChild(node, i);
+			if (component === null) return null;
+			if (component.length === 0) return EmptySetV;
+			args.push(component);
+		}
+		const result = cartesianProduct(args);
+		if (result === null) {
+			this.onError(RSErrorCode.setOverflow, node, [String(SET_INFINITY)]);
+			return null;
+		}
+		return result;
+	}
+	visitBoolean(node) {
+		const base = this.visitChild(node, 0);
+		if (base === null) return null;
+		const result = boolean(base);
+		if (result === null) {
+			this.onError(RSErrorCode.booleanBaseLimit, node.children[0], [String(18)]);
+			return null;
+		}
+		return result;
+	}
+	visitTuple(node) {
+		const args = [];
+		for (let i = 0; i < node.children.length; i++) {
+			const component = this.visitChild(node, i);
+			if (component === null) return null;
+			args.push(component);
+		}
+		return tuple(args);
+	}
+	visitEnumeration(node) {
+		const args = [];
+		for (let i = 0; i < node.children.length; i++) {
+			const element = this.visitChild(node, i);
+			if (element === null) return null;
+			args.push(element);
+		}
+		return set(args);
+	}
+	visitBool(node) {
+		const element = this.visitChild(node, 0);
+		if (element === null) return null;
+		return [element];
+	}
+	visitDebool(node) {
+		const target = this.visitChild(node, 0);
+		if (target === null) return null;
+		if (target.length !== 1) return this.onError(RSErrorCode.calcInvalidDebool, node.children[0]);
+		return target[0];
+	}
+	visitSetexprBinary(node) {
+		const v1 = this.visitChild(node, 0);
+		if (v1 === null) return null;
+		const v2 = this.visitChild(node, 1);
+		if (v2 === null) return null;
+		switch (node.typeID) {
+			case TokenID.SET_UNION: return setUnion(v1, v2);
+			case TokenID.SET_INTERSECTION: return setIntersection(v1, v2);
+			case TokenID.SET_MINUS: return setDiff(v1, v2);
+			case TokenID.SET_SYMMETRIC_MINUS: return setSymDiff(v1, v2);
+		}
+		return null;
+	}
+	visitProjectSet(node) {
+		const target = this.visitChild(node, 0);
+		if (target === null) return null;
+		return projection(target, getNodeIndices(node));
+	}
+	visitProjectTuple(node) {
+		const target = this.visitChild(node, 0);
+		if (target === null) return null;
+		const components = getNodeIndices(node).map((i) => target[i]);
+		return components.length === 1 ? components[0] : tuple(components);
+	}
+	visitFilter(node) {
+		const lastIdx = node.children.length - 1;
+		const argVal = this.visitChild(node, lastIdx);
+		if (argVal === null) return null;
+		if (argVal.length === 0) return EmptySetV;
+		const indices = getNodeIndices(node);
+		if (indices.length === lastIdx) {
+			const params = [];
+			for (let i = 0; i < lastIdx; i++) {
+				const param = this.visitChild(node, i);
+				if (param === null) return null;
+				if (param.length === 0) return EmptySetV;
+				params.push(param);
+			}
+			const result = [];
+			for (const element of argVal) {
+				let valid = true;
+				for (let j = 0; j < indices.length; j++) {
+					const comp = element[indices[j]];
+					const paramSet = params[j];
+					if (!contains(paramSet, comp)) {
+						valid = false;
+						break;
+					}
+				}
+				if (valid) result.push(element);
+			}
+			return result;
+		} else {
+			const paramVal = this.visitChild(node, 0);
+			if (paramVal === null) return null;
+			if (paramVal.length === 0) return EmptySetV;
+			const result = [];
+			for (const element of argVal) {
+				const comps = indices.map((i) => element[i]);
+				if (contains(paramVal, comps.length === 1 ? comps[0] : tuple(comps))) result.push(element);
+			}
+			return result;
+		}
+	}
+	visitReduce(node) {
+		const target = this.visitChild(node, 0);
+		if (target === null) return null;
+		return reduce(target);
+	}
+	visitDeclarative(node) {
+		const domain = this.visitChild(node, 1);
+		if (domain === null) return null;
+		const elements = [];
+		for (const element of domain) {
+			if (!this.tick(node, TICK_PER_DECLARATIVE)) return null;
+			this.dispatchDeclare(node.children[0], element);
+			const value = this.visitChild(node, 2);
+			if (value === null) return null;
+			if (value === 1) elements.push(element);
+		}
+		return elements.length === 0 ? EmptySetV : elements;
+	}
+	visitImperative(node) {
+		const result = [];
+		const frames = [];
+		let currentChild = 1;
+		const advanceIterator = () => {
+			while (frames.length > 0) {
+				const top = frames[frames.length - 1];
+				if (top.valueID < top.domain.length - 1) {
+					top.valueID++;
+					const nextValue = top.domain[top.valueID];
+					if (!this.tick(node.children[top.childID], TICK_PER_IMPERATIVE)) return false;
+					this.dispatchDeclare(node.children[top.childID].children[0], nextValue);
+					currentChild = top.childID + 1;
+					return true;
+				}
+				frames.pop();
+			}
+			return false;
+		};
+		while (true) {
+			if (currentChild >= node.children.length) {
+				const element = this.visitChild(node, 0);
+				if (element === null) return null;
+				result.push(element);
+				if (!advanceIterator()) break;
+				continue;
+			}
+			const child = node.children[currentChild];
+			if (child.typeID === TokenID.ITERATE) {
+				const domain = this.visitChild(child, 1);
+				if (domain === null) return null;
+				if (domain.length === 0) {
+					if (!advanceIterator()) break;
+					continue;
+				}
+				if (!this.tick(child, TICK_PER_IMPERATIVE)) return null;
+				frames.push({
+					childID: currentChild,
+					domain,
+					valueID: 0
+				});
+				this.dispatchDeclare(child.children[0], domain[0]);
+				currentChild++;
+				continue;
+			}
+			const value = this.dispatchVisit(child);
+			if (value === null) return null;
+			if (value === 0) {
+				if (!advanceIterator()) break;
+				continue;
+			}
+			currentChild++;
+		}
+		return set(result);
+	}
+	visitAssign(node) {
+		const value = this.visitChild(node, 1);
+		if (value === null) return null;
+		this.dispatchDeclare(node.children[0], value);
+		return 1;
+	}
+	visitRecursion(node) {
+		const initialValue = this.visitChild(node, 1);
+		if (initialValue === null) return null;
+		const bodyIndex = node.typeID === TokenID.NT_RECURSIVE_FULL ? 3 : 2;
+		let current = initialValue;
+		while (true) {
+			if (!this.tick(node, TICK_PER_RECURSION)) return null;
+			this.dispatchDeclare(node.children[0], current);
+			if (node.typeID === TokenID.NT_RECURSIVE_FULL) {
+				const pred = this.visitChild(node, 2);
+				if (pred === null) return null;
+				if (pred !== 1) break;
+			}
+			const next = this.visitChild(node, bodyIndex);
+			if (next === null) return null;
+			if (compare(current, next) === 0) break;
+			current = next;
+		}
+		return current;
+	}
 };
+/** Local variables context. */
 var LocalContext = class {
-  nextBindingId = 1;
-  data = /* @__PURE__ */ new Map();
-  callStack = [];
-  startScope() {
-    this.callStack.push(this.data);
-    this.data = /* @__PURE__ */ new Map();
-  }
-  endScope() {
-    this.data = this.callStack.pop();
-  }
-  setLocal(alias, value) {
-    const existing = this.data.get(alias);
-    if (existing) {
-      existing.value = value;
-      existing.version++;
-    } else {
-      this.data.set(alias, { id: this.nextBindingId++, version: 0, value });
-    }
-  }
-  getLocal(alias) {
-    const binding = this.data.get(alias);
-    if (binding === void 0) {
-      throw new Error(`Local variable "${alias}" not found`);
-    }
-    return binding.value;
-  }
-  buildDependencyStamp(reads) {
-    if (reads.size === 0) {
-      return "";
-    }
-    const parts = [];
-    for (const alias of [...reads].sort()) {
-      const binding = this.data.get(alias);
-      if (binding === void 0) {
-        return null;
-      }
-      parts.push(`${binding.id}:${binding.version}`);
-    }
-    return parts.join("|");
-  }
-};
-export {
-  Evaluator
+	nextBindingId = 1;
+	data = /* @__PURE__ */ new Map();
+	callStack = [];
+	startScope() {
+		this.callStack.push(this.data);
+		this.data = /* @__PURE__ */ new Map();
+	}
+	endScope() {
+		this.data = this.callStack.pop();
+	}
+	setLocal(alias, value) {
+		const existing = this.data.get(alias);
+		if (existing) {
+			existing.value = value;
+			existing.version++;
+		} else this.data.set(alias, {
+			id: this.nextBindingId++,
+			version: 0,
+			value
+		});
+	}
+	getLocal(alias) {
+		const binding = this.data.get(alias);
+		if (binding === void 0) throw new Error(`Local variable "${alias}" not found`);
+		return binding.value;
+	}
+	buildDependencyStamp(reads) {
+		if (reads.size === 0) return "";
+		const parts = [];
+		for (const alias of [...reads].sort()) {
+			const binding = this.data.get(alias);
+			if (binding === void 0) return null;
+			parts.push(`${binding.id}:${binding.version}`);
+		}
+		return parts.join("|");
+	}
 };
+//#endregion
+export { Evaluator };
+
 //# sourceMappingURL=evaluator.js.map