@rsconcept/domain 1.0.0

package/dist/library/index.js

@@ -0,0 +1,2800 @@
+// src/library/folder-tree.ts
+var FolderNode = class _FolderNode {
+  rank = 0;
+  text;
+  children;
+  parent;
+  filesInside = 0;
+  filesTotal = 0;
+  constructor(text, parent = null) {
+    this.text = text;
+    this.parent = parent;
+    this.children = /* @__PURE__ */ new Map();
+    if (parent) {
+      this.rank = parent.rank + 1;
+    }
+  }
+  addChild(text) {
+    const node = new _FolderNode(text, this);
+    this.children.set(text, node);
+    return node;
+  }
+  hasPredecessor(target) {
+    if (this.parent === target) {
+      return true;
+    } else if (!this.parent) {
+      return false;
+    }
+    let node = this.parent;
+    while (node.parent) {
+      if (node.parent === target) {
+        return true;
+      }
+      node = node.parent;
+    }
+    return false;
+  }
+  incrementFiles(count = 1) {
+    this.filesInside = this.filesInside + count;
+    this.incrementTotal(count);
+  }
+  incrementTotal(count = 1) {
+    this.filesTotal = this.filesTotal + count;
+    if (this.parent) {
+      this.parent.incrementTotal(count);
+    }
+  }
+  getPath() {
+    const suffix = this.text ? `/${this.text}` : "";
+    if (!this.parent) {
+      return suffix;
+    } else {
+      return this.parent.getPath() + suffix;
+    }
+  }
+};
+var FolderTree = class {
+  roots = /* @__PURE__ */ new Map();
+  constructor(arr) {
+    arr?.forEach((path) => this.addPath(path));
+  }
+  at(path) {
+    let parse = ChopPathHead(path);
+    if (!this.roots.has(parse.head)) {
+      return void 0;
+    }
+    let node = this.roots.get(parse.head);
+    while (parse.tail !== "") {
+      parse = ChopPathHead(parse.tail);
+      if (!node.children.has(parse.head)) {
+        return void 0;
+      }
+      node = node.children.get(parse.head);
+    }
+    return node;
+  }
+  getTree() {
+    const result = [];
+    this.roots.forEach((root) => this.visitNode(root, result));
+    return result;
+  }
+  visitNode(target, result) {
+    result.push(target);
+    [...target.children.keys()].sort((a, b) => a.localeCompare(b)).forEach((key) => this.visitNode(target.children.get(key), result));
+  }
+  addPath(path, filesCount = 1) {
+    let parse = ChopPathHead(path);
+    if (!parse.head) {
+      throw Error(`Invalid path ${path}`);
+    }
+    let node = this.roots.has(parse.head) ? this.roots.get(parse.head) : this.addNode(parse.head);
+    while (parse.tail !== "") {
+      parse = ChopPathHead(parse.tail);
+      if (node.children.has(parse.head)) {
+        node = node.children.get(parse.head);
+      } else {
+        node = this.addNode(parse.head, node);
+      }
+    }
+    node.incrementFiles(filesCount);
+    return node;
+  }
+  addNode(text, parent) {
+    if (!parent) {
+      const newNode = new FolderNode(text);
+      this.roots.set(text, newNode);
+      return newNode;
+    } else {
+      return parent.addChild(text);
+    }
+  }
+};
+function ChopPathHead(path) {
+  if (path?.at(0) !== "/") {
+    return {
+      head: "",
+      tail: ""
+    };
+  }
+  const slash = path.indexOf("/", 1);
+  if (slash === -1) {
+    return {
+      head: path.substring(1),
+      tail: ""
+    };
+  } else {
+    return {
+      head: path.substring(1, slash),
+      tail: path.substring(slash)
+    };
+  }
+}
+
+// src/library/library.ts
+var LibraryItemType = {
+  RSFORM: "rsform",
+  OSS: "oss",
+  RSMODEL: "rsmodel"
+};
+var AccessPolicy = {
+  PUBLIC: "public",
+  PROTECTED: "protected",
+  PRIVATE: "private"
+};
+var LocationHead = {
+  USER: "/U",
+  COMMON: "/S",
+  LIBRARY: "/L",
+  PROJECTS: "/P"
+};
+
+// src/library/oss.ts
+var NodeType = {
+  OPERATION: 1,
+  BLOCK: 2
+};
+var OperationType = {
+  INPUT: "input",
+  SYNTHESIS: "synthesis",
+  REPLICA: "replica"
+};
+var SubstitutionErrorType = {
+  invalidIDs: 0,
+  incorrectCst: 1,
+  invalidClasses: 2,
+  invalidBasic: 3,
+  invalidConstant: 4,
+  typificationCycle: 5,
+  baseSubstitutionNotSet: 6,
+  unequalTypification: 7,
+  unequalExpressions: 8,
+  unequalArgsCount: 9,
+  unequalArgs: 10,
+  invalidNominal: 11
+};
+
+// 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/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/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 TypeClass = {
+  logic: 1,
+  typification: 2,
+  function: 3,
+  predicate: 4
+};
+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 basic(alias) {
+  return { typeID: TypeID.basic, baseID: alias };
+}
+function constant(alias) {
+  return { typeID: TypeID.basic, baseID: alias, isOrdered: true, isArithmetic: true, isIntegerCompatible: true };
+}
+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;
+}
+function isSetValue(data) {
+  return Array.isArray(data) && (data.length === 0 || data[0] !== TUPLE_ID);
+}
+function isTupleValue(data) {
+  return Array.isArray(data) && data.length > 1 && data[0] === TUPLE_ID;
+}
+function validateValue(value, type, basics) {
+  switch (type.typeID) {
+    case TypeID.integer:
+      return typeof value === "number";
+    case TypeID.logic: {
+      if (typeof value !== "number") {
+        return false;
+      }
+      return value === VALUE_TRUE || value === VALUE_FALSE;
+    }
+    case TypeID.basic: {
+      if (typeof value !== "number") {
+        return false;
+      }
+      const domain = basics.get(type.baseID);
+      return !!domain && Array.isArray(domain) && domain.includes(value);
+    }
+    case TypeID.tuple: {
+      if (!Array.isArray(value) || value.length !== type.factors.length + 1 || value[0] !== TUPLE_ID) {
+        return false;
+      }
+      for (let i = 0; i < type.factors.length; i++) {
+        if (!validateValue(value[i + 1], type.factors[i], basics)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case TypeID.collection: {
+      if (!isSetValue(value)) {
+        return false;
+      }
+      for (const item of value) {
+        if (!validateValue(item, type.base, basics)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    case TypeID.anyTypification:
+    case TypeID.predicate:
+    case TypeID.function:
+      return false;
+  }
+}
+
+// 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;
+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 component2 = this.visitChild(node, i);
+      if (component2 === null) {
+        return null;
+      }
+      if (component2.length === 0) {
+        return EmptySetV;
+      }
+      args.push(component2);
+    }
+    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 component2 = this.visitChild(node, i);
+      if (component2 === null) {
+        return null;
+      }
+      args.push(component2);
+    }
+    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;
+  }
+};
+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("|");
+  }
+};
+
+// src/rslang/eval/calculator.ts
+var RSCalculator = class {
+  context = /* @__PURE__ */ new Map();
+  treeContext = /* @__PURE__ */ new Map();
+  evaluator = new Evaluator(this.context, this.treeContext);
+  listeners = /* @__PURE__ */ new Map();
+  subscribe = (alias, listener) => {
+    let notifyList = this.listeners.get(alias);
+    if (!notifyList) {
+      notifyList = /* @__PURE__ */ new Set();
+      this.listeners.set(alias, notifyList);
+    }
+    notifyList.add(listener);
+    return () => {
+      notifyList.delete(listener);
+      if (notifyList.size === 0) {
+        this.listeners.delete(alias);
+      }
+    };
+  };
+  setValue(alias, value) {
+    this.context.set(alias, value);
+    this.notify(alias);
+  }
+  resetValue(alias) {
+    this.context.delete(alias);
+    this.notify(alias);
+  }
+  clearAllAst() {
+    this.treeContext.clear();
+  }
+  getValue(alias) {
+    return this.context.get(alias) ?? null;
+  }
+  setAST(alias, ast) {
+    this.treeContext.set(alias, ast);
+  }
+  validate(value, type) {
+    return validateValue(value, type, this.context);
+  }
+  evaluateFast(ast) {
+    if (ast.hasError) {
+      return null;
+    }
+    return this.evaluator.run(ast);
+  }
+  evaluateFull(ast, options) {
+    const errors = [];
+    const reporter = (error) => {
+      errors.push(error);
+    };
+    if (ast.hasError) {
+      return { value: null, iterations: 0, cacheHits: 0, errors };
+    }
+    const value = this.evaluator.run(ast, reporter, options?.annotateErrors ?? false, options?.disableCache ?? false);
+    if (value === null && errors.length === 0) {
+      errors.push({ code: RSErrorCode.calcUnknownError, from: 0, to: 0 });
+      if (options?.annotateErrors) {
+        annotateError(ast, RSErrorCode.calcUnknownError);
+      }
+    }
+    return {
+      value,
+      iterations: this.evaluator.iterationCounter,
+      cacheHits: this.evaluator.cacheHits,
+      errors
+    };
+  }
+  notify(alias) {
+    const set2 = this.listeners.get(alias);
+    if (!set2) return;
+    for (const l of set2) {
+      l();
+    }
+  }
+};
+
+// src/rslang/parser/parser.ts
+import { LRParser } from "@lezer/lr";
+var parser = LRParser.deserialize({
+  version: 14,
+  states: "2lO!sQPOOOVQPO'#CdO$qQPO'#C`O&pQPO'#C`O*bQPO'#C_Q*jQPOOO,TQPO'#CyOVQPO'#CtO,]QPO'#CtOOQO'#Ct'#CtOOQO'#C^'#C^OOQO'#ES'#ESOOQO'#ET'#ETO,bQPO'#DeO,iQPO'#DfO,qQPO'#DhO,vQPO'#DjO,{QPO'#DnO-QQPO'#DrOOQO'#EU'#EUOOQO'#EV'#EVOOQO'#DS'#DSO-VQPO'#DSO-[QPO'#DSOOQO'#EQ'#EQO,TQPO'#DzQOQPOOO-aQPO'#ERO-nQPO,59OO-vQPO'#CeO-{QPO,58xO/lQPO,59tOVQPO,58yOVQPO,58yOVQPO,59iOVQPO,59iOVQPO,59iOVQPO,59iOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO,59tOVQPO'#CdOOQO'#C`'#C`OOQO'#C{'#C{O1]QPO,59eO2rQPO,59`OVQPO,59`OOQO'#ER'#ERO5TQPO,5:PO5]QPO,5:UOVQPO,5:QOOQO,5:Q,5:QOVQPO,5:SO,TQPO,5:UOVQPO,5:YO,TQPO,5:^OVQPO,59nOVQPO,59nO5dQPO'#D|OOQO'#D{'#D{O5iQPO,5:fOOQO1G.j1G.jOVQPO,59POOQO1G.d1G.dOOQO1G/`1G/`O5qQPO1G.eO7vQPO1G.eO:zQPO1G/TO=]QPO1G/TO?nQPO1G/TOBPQPO1G/TOGyQPO1G/`OHQQPO1G/`OKpQPO1G/`O! `QPO1G/`O! gQPO1G/`O! nQPO1G/`O! uQPO1G/`O,TQPO,59gOVQPO1G/PO!%aQPO1G.zOOQO1G/k1G/kOVQPO1G/pO!%iQPO1G/lO!%pQPO1G/nO!%xQPO1G/pO!%}QPO1G/tO!&UQPO1G/xO!&ZQPO1G/YO!&cQPO1G/YOVQPO,5:hO,TQPO,5:gOVQPO1G0QO!&jQPO1G.kOOQO1G/R1G/RO!&zQPO7+$kOOQO7+$f7+$fO!(gQPO7+%[OOQO7+%W7+%WO!(nQPO7+%YOVQPO7+%[OVQPO7+%`OVQPO7+%dOOQO7+$t7+$tO!(sQPO1G0SOOQO1G0R1G0RO!(}QPO7+%lO!)UQPO<<HVOVQPO<<HvOVQPO<<HtO!+gQPO<<HvO!+nQPO'#DoO!+xQPO<<HzO!,QQPO<<IOO!,XQPOAN>bO!,`QPOAN>`OVQPOAN>bOVQPO,5:ZOOQOAN>fAN>fOVQPOAN>jOOQOG23|G23|OOQOG23zG23zO!,gQPOG23|O!,nQPO1G/uO!,xQPOG24UOOQOLD)hLD)hOOQOLD)pLD)pOVQPOLD)pO!-SQPO!$'M[OOQO!)9Bv!)9Bv",
+  stateData: "!-l~O!sOS~OTQOVPOiVOjWOnUOpUOwZOxZOyZOz[O{[O!W]O!Z^O!]_O!``O!aaO!ebO!gfO!hdO!idO!jdO!kdO!ldO!mdO~OkiO~PVOZSX[SX]!wX^!wX_!wX`!wXa!wXb!wXc!wXd!wXe!wXf!wXg!wXr!wXs!wXt!wXu!wX}!wX!O!wX!P!wX!Q!wX!R!wX!S!wX!T!wX!U!wXY!wX!V!wX~O!q!wXU!wXl!wX!_!wXT!wXV!wXi!wXj!wXn!wXp!wXw!wXx!wXy!wXz!wX{!wX!W!wX!Z!wX!]!wX!`!wX!a!wX!e!wX!g!wX!h!wX!i!wX!j!wX!k!wX!l!wX!m!wX!d!wX~P!zOZSX[SX]!xX^!xX_!xX`!xXa!xXb!xXc!xXd!xXe!xXf!xXg!xXr!xXs!xXt!xXu!xX}!xX!O!xX!P!xX!Q!xX!R!xX!S!xX!T!xX!U!xX!q!xXY!xX!V!xXU!xXl!xX!_!xXT!xXV!xXi!xXj!xXn!xXp!xXw!xXx!xXy!xXz!xX{!xX!W!xX!Z!xX!]!xX!`!xX!a!xX!e!xX!g!xX!h!xX!i!xX!j!xX!k!xX!l!xX!m!xX!d!xX~OZpO[pO~O]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqOrrOssOttOuuO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~OT!POV!OO~Ok!TO~OT!WO~PYOV!XO!Z^O~Ok!ZO~O!W![O~O!W!]O~O!W!^O~Ok!_O~OV!`O~OY!uX!V!uXl!uX~P*jOU!dOY!uX~OY!eO~OU!fOY!tX]!tX^!tX_!tX`!tXa!tXb!tXc!tXd!tXe!tXf!tXg!tXr!tXs!tXt!tXu!tX}!tX!O!tX!P!tX!Q!tX!R!tX!S!tX!T!tX!U!tX~OU!gOYvX]vX^vX_vX`vXavXbvXcvXdvXevXfvXgvXrvXsvXtvXuvX}vX!OvX!PvX!QvX!RvX!SvX!TvX!UvX~OY!uO]!vO~O]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~Orhashathauha!qhaUhaYha!Vhalha!_haThaVhaihajhanhaphawhaxhayhazha{ha!Wha!Zha!]ha!`ha!aha!eha!gha!hha!iha!jha!kha!lha!mha!dha~P1eOY!eO!V!xO~O]!yO~P!zO]#RO~OY#SOl#TO~O!qRiURiYRi!VRilRi!_RiTRiVRiiRijRinRipRiwRixRiyRizRi{Ri!WRi!ZRi!]Ri!`Ri!aRi!eRi!gRi!hRi!iRi!jRi!kRi!lRi!mRi!dRi~P*jO]Ri^Ri_Ri`RiaRibRicRidRieRifRigRirRisRitRiuRi!qRiURiYRi!VRilRi!_RiTRiVRiiRijRinRipRiwRixRiyRizRi{Ri!WRi!ZRi!]Ri!`Ri!aRi!eRi!gRi!hRi!iRi!jRi!kRi!lRi!mRi!dRi~P+iOssOttOuuOrqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOttOuuOrqisqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOuuOrqisqitqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eOrqisqitqiuqi!qqiUqiYqi!Vqilqi!_qiTqiVqiiqijqinqipqiwqixqiyqizqi{qi!Wqi!Zqi!]qi!`qi!aqi!eqi!gqi!hqi!iqi!jqi!kqi!lqi!mqi!dqi~P1eO}vO]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!P|i!Q|i!R|i!S|i!T|i!U|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!O|i~PDbO!OwO~PDbO}vO!OwO!PxO!U}O]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!R|i!S|i!T|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!Q|i~PHXO}vO!OwO!PxO!QyO!T|O!U}O]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!S|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~O!R|i~PKwO!RzO~PKwO!QyO~PHXO}vO!OwO!PxO]|i^|i_|i`|ia|ib|ic|id|ie|if|ig|ir|is|it|iu|i!Q|i!R|i!S|i!T|i!U|i!q|iU|iY|i!V|il|i!_|iT|iV|ii|ij|in|ip|iw|ix|iy|iz|i{|i!W|i!Z|i!]|i!`|i!a|i!e|i!g|i!h|i!i|i!j|i!k|i!l|i!m|i!d|i~OY!eOl#XO~OU#ZO~P*jOY!eOl#[O~O]#]O~O!_#^O~P*jO[#_O~OY!eOl#`O~OU#`O~P*jOUXiYXi!VXilXi~P*jO]qO^qO_qO`qOaqObqOcqOdqOeqOfqOgqOrrOssOttOuuO}vO!OwO!PxO!QyO!RzO!S{O!T|O!U}O~PVO!_#eO~P*jOV#fO~OY!pil!pi~P*jO!q!nq~P*jOrmysmytmyumy!qmyUmyYmy!Vmylmy!_myTmyVmyimyjmynmypmywmyxmyymyzmy{my!Wmy!Zmy!]my!`my!amy!emy!gmy!hmy!imy!jmy!kmy!lmy!mmy!dmy~P1eO!_#mO~P*jO!V!cX!d!cX~P*jO!V#oO!d#nO~O!_#pO~P*jO!V#qO~P*jOU#rO~P*jO!V#vO~P*jO!V!ci!d!ci~P*jO!V#wO!_#xO~P*jO!V#zO~P*jO!]!hj!gz{!j!k!l!m!iT!e!a!`!a~",
+  goto: "1O!zPP!{#y$uPPP&R'VPPPPPPPPPPPPPP#yPPPP'aP(]P#yPPPP(`PPPPP)[PPPPPPPPPP*Y+UP*YP*YPPP*Y,TPP*YPPPPPPP,W,Z,^PPP,d.v/W/W/W0S!phOV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xRnP!sYOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!rSOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xQ!QUS!ai#SQ!|![Q#O!^R#V!u!rROPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x]!PUi![!^!u#SSlP!OX!U]!T!Z!_!sXOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xR!RU!shOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!peOV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xRoP!scOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!rcOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#xR!Y^R#i#^RjOR!ciQ!biR#b#SQTO[kP]!O!T!Z!_Q!SVQ!gvQ!hpQ!iqQ!jrQ!ksQ!ltQ!muQ!nwQ!oxQ!pyQ!qzQ!r{Q!s|Q!t}Q!z!XQ!}!]Q#Q!`Q#U!eQ#W!vQ#Y!yQ#a#RQ#c#TQ#d#WQ#g#]Q#h#^Q#j#_Q#k#eQ#l#fQ#s#mQ#t#nQ#u#pR#y#xSmP!OQ!V]Q!w!TQ!{!ZR#P!_!seOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x!sgOPV]pqrstuvwxyz{|}!O!T!X!Z!]!_!`!e!v!y#R#T#W#]#^#_#e#f#m#n#p#x",
+  nodeNames: "\u26A0 Expression Logic Logic_predicates Variable Local ) ( Tuple Expr_enum_min2 , :\u2208 := \u2208 \u2209 \u2286 \u2284 \u2282 > \u2265 < \u2264 \u2260 = Logic_unary \xAC Predicate [ ] Logic_quantor \u2200 Variable_pack \u2203 Logic_binary \u21D4 \u21D2 \u2228 & Setexpr Integer EmptySet IntegerSet Global Radical Setexpr_binary * + - \u222A \\ \u2206 \u2229 \xD7 } { Enumeration Boolean \u212C Filter_expression Filter Declarative | PrefixD PrefixI Imperative Imp_blocks ; PrefixR Recursion Function BigPr SmallPr Card Bool Debool Red Function_decl Arguments Declaration",
+  maxTerm: 87,
+  nodeProps: [
+    ["openedBy", 6, "(", 53, "{"],
+    ["closedBy", 7, ")", 54, "}"]
+  ],
+  skippedNodes: [0],
+  repeatNodeCount: 0,
+  tokenData: "6j~R!jX^%spq%svw&hxy&myz&rz{&w{|&||}'R}!O'W!Q![']![!]'e!]!^'x!^!_'}!_!`(S!`!a(X!c!d(^!e!f(^!f!g(l!h!i(t!k!l)h!p!q(^!r!s)m!t!u*a!u!v(^!v!w(^!z!{(^!|!}*q!}#O*v#O#P*{#P#Q+Q#R#S+V#T#U+V#U#V+m#V#W-]#W#X.x#X#d+V#d#e1b#e#f+V#f#g2w#g#o+V#o#p4R#p#q4W#q#r4]#y#z%s$f$g%s$r$s4b%o%p4g5i6S+V#BY#BZ%s$IS$I_%s$I|$JO%s$JT$JU%s$KV$KW%s% l% m4l%%Y%%Z4q%%[%%]4v%&Y%&Z4{%&]%&^5Q%&_%&`5V%&`%&a5[%&b%&c5a%&c%&d5f%'S%'T5k%'T%'U5p%'U%'V5u%(^%(_5z%(b%(c6P%(c%(d6U%)Q%)R6Z%)S%)T6`%)U%)V6e&FU&FV%s~%xY!s~X^%spq%s#y#z%s$f$g%s#BY#BZ%s$IS$I_%s$I|$JO%s$JT$JU%s$KV$KW%s&FU&FV%s~&mOu~~&rOV~~&wOU~~&|O}~~'RO!O~~'WOY~~']O!P~~'bPw~!Q![']~'hQ!_!`'n%&b%&c's~'sO[~~'xOZ~~'}O!d~~(SOd~~(XOg~~(^Ob~~(aP!Q![(d~(iPz~!Q![(d~(qP!`~!Q![(d~(wQ!Q![(}#]#^)V~)SP!g~!Q![(}~)YP!R![)]~)bQ!]~|})V!Q![)]~)mO!a~~)pQ!Q![)v#f#g*O~){Pj~!Q![)v~*RP!R![*U~*ZQ!h~|}*O!Q![*U~*fP!e~!Q![*i~*nP{~!Q![*i~*vOy~~*{Ok~~+QO!R~~+VOl~~+[RT~!Q![+e#T#o+V5i6S+V~+jPT~!Q![+e~+rTT~!Q![+e#T#c+V#c#d,R#d#o+V5i6S+V~,WTT~!Q![+e#T#c+V#c#d,g#d#o+V5i6S+V~,lTT~!Q![+e#T#`+V#`#a,{#a#o+V5i6S+V~-SR!k~T~!Q![+e#T#o+V5i6S+V~-bST~!Q![+e#T#U-n#U#o+V5i6S+V~-sTT~!Q![+e#T#f+V#f#g.S#g#o+V5i6S+V~.XTT~!Q![+e#T#W+V#W#X.h#X#o+V5i6S+V~.oR!j~T~!Q![+e#T#o+V5i6S+V~.}TT~!Q![+e#T#X+V#X#Y/^#Y#o+V5i6S+V~/cTT~!Q![+e#T#U+V#U#V/r#V#o+V5i6S+V~/wTT~!Q![+e#T#c+V#c#d0W#d#o+V5i6S+V~0]TT~!Q![+e#T#c+V#c#d0l#d#o+V5i6S+V~0qTT~!Q![+e#T#`+V#`#a1Q#a#o+V5i6S+V~1XR!l~T~!Q![+e#T#o+V5i6S+V~1gTT~!Q![+e#T#f+V#f#g1v#g#o+V5i6S+V~1{ST~!Q!R+e!R![2X#T#o+V5i6S+V~2`Q!i~T~|}2f!Q![2X~2iP!R![2l~2qQ!i~|}2f!Q![2l~2|TT~!Q![+e#T#X+V#X#Y3]#Y#o+V5i6S+V~3bTT~!Q![+e#T#W+V#W#X3q#X#o+V5i6S+V~3xR!m~T~!Q![+e#T#o+V5i6S+V~4WO!W~~4]O!_~~4bO!V~~4gOi~~4lO!U~~4qO!Z~~4vOs~~4{Or~~5QOn~~5VOp~~5[Ox~~5aO!S~~5fO]~~5kO^~~5pOt~~5uO!T~~5zO!Q~~6POf~~6UOe~~6ZOc~~6`Oa~~6eO`~~6jO_~",
+  tokenizers: [0],
+  topRules: { "Expression": [0, 1] },
+  tokenPrec: 2679
+});
+
+// src/rslang/parser/parser.terms.ts
+var Local = 5;
+var Tuple = 8;
+var Predicate = 26;
+var Variable_pack = 31;
+var Integer = 39;
+var EmptySet = 40;
+var IntegerSet = 41;
+var Global = 42;
+var Radical = 43;
+var Enumeration = 55;
+var Boolean = 56;
+var Filter = 59;
+var Declarative = 60;
+var Imperative = 64;
+var Function = 69;
+var BigPr = 70;
+var SmallPr = 71;
+var Card = 72;
+var Bool = 73;
+var Debool = 74;
+var Red = 75;
+var Function_decl = 76;
+var Arguments = 77;
+var Declaration = 78;
+
+// src/rslang/parser/normalize.ts
+var idRecord = {
+  [Global]: TokenID.ID_GLOBAL,
+  [Local]: TokenID.ID_LOCAL,
+  [Radical]: TokenID.ID_RADICAL,
+  [Function]: TokenID.ID_FUNCTION,
+  [Predicate]: TokenID.ID_PREDICATE,
+  [Integer]: TokenID.LIT_INTEGER,
+  [EmptySet]: TokenID.LIT_EMPTYSET,
+  [IntegerSet]: TokenID.LIT_WHOLE_NUMBERS,
+  [Boolean]: TokenID.BOOLEAN,
+  [BigPr]: TokenID.BIGPR,
+  [SmallPr]: TokenID.SMALLPR,
+  [Filter]: TokenID.FILTER,
+  [Bool]: TokenID.BOOL,
+  [Debool]: TokenID.DEBOOL,
+  [Red]: TokenID.REDUCE,
+  [Card]: TokenID.CARD,
+  [Enumeration]: TokenID.NT_ENUMERATION,
+  [Tuple]: TokenID.NT_TUPLE,
+  [Arguments]: TokenID.NT_ARGUMENTS,
+  [Declaration]: TokenID.NT_ARG_DECL,
+  [Function_decl]: TokenID.NT_FUNC_DEFINITION,
+  [Variable_pack]: TokenID.NT_ENUM_DECL,
+  [Declarative]: TokenID.NT_DECLARATIVE_EXPR,
+  [Imperative]: TokenID.NT_IMPERATIVE_EXPR
+};
+
+// src/rslang/labels.ts
+var ANY_TYPE_NAME = "R0";
+var LOGIC_TYPE_NAME = "Logic";
+var labelTokenRecord = {
+  [TokenID.DECART]: "\xD7",
+  [TokenID.PUNCTUATION_PL]: "( )",
+  [TokenID.PUNCTUATION_SL]: "[ ]",
+  [TokenID.QUANTOR_UNIVERSAL]: "\u2200",
+  [TokenID.QUANTOR_EXISTS]: "\u2203",
+  [TokenID.LOGIC_NOT]: "\xAC",
+  [TokenID.LOGIC_AND]: "&",
+  [TokenID.LOGIC_OR]: "\u2228",
+  [TokenID.LOGIC_IMPLICATION]: "\u21D2",
+  [TokenID.LOGIC_EQUIVALENT]: "\u21D4",
+  [TokenID.LIT_EMPTYSET]: "\u2205",
+  [TokenID.LIT_WHOLE_NUMBERS]: "Z",
+  [TokenID.MULTIPLY]: "*",
+  [TokenID.EQUAL]: "=",
+  [TokenID.NOTEQUAL]: "\u2260",
+  [TokenID.GREATER_OR_EQ]: "\u2265",
+  [TokenID.LESSER_OR_EQ]: "\u2264",
+  [TokenID.SET_IN]: "\u2208",
+  [TokenID.SET_NOT_IN]: "\u2209",
+  [TokenID.SUBSET_OR_EQ]: "\u2286",
+  [TokenID.SUBSET]: "\u2282",
+  [TokenID.NOT_SUBSET]: "\u2284",
+  [TokenID.SET_INTERSECTION]: "\u2229",
+  [TokenID.SET_UNION]: "\u222A",
+  [TokenID.SET_MINUS]: "\\",
+  [TokenID.SET_SYMMETRIC_MINUS]: "\u2206",
+  [TokenID.BOOLEAN]: "\u212C()",
+  [TokenID.NT_DECLARATIVE_EXPR]: "D{}",
+  [TokenID.NT_IMPERATIVE_EXPR]: "I{}",
+  [TokenID.NT_RECURSIVE_FULL]: "R{}",
+  [TokenID.BIGPR]: "Pr1()",
+  [TokenID.SMALLPR]: "pr1()",
+  [TokenID.FILTER]: "Fi1[]()",
+  [TokenID.REDUCE]: "red()",
+  [TokenID.CARD]: "card()",
+  [TokenID.BOOL]: "bool()",
+  [TokenID.DEBOOL]: "debool()",
+  [TokenID.ASSIGN]: ":=",
+  [TokenID.ITERATE]: ":\u2208"
+};
+function normalizeType(type) {
+  if (!type) {
+    return "N/A";
+  }
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+      return ANY_TYPE_NAME;
+    case TypeID.integer:
+    case TypeID.basic:
+      return "X1";
+    case TypeID.tuple:
+      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${normalizeType(factor)})` : normalizeType(factor)).join("\xD7");
+    case TypeID.collection:
+      return type.base.typeID === TypeID.collection ? `\u212C${normalizeType(type.base)}` : `\u212C(${normalizeType(type.base)})`;
+    case TypeID.logic:
+      return LOGIC_TYPE_NAME;
+    case TypeID.predicate:
+    case TypeID.function:
+      const argsText = type.args.map((arg) => normalizeType(arg.type)).join(", ");
+      return `[${argsText}] \u2192 ${normalizeType(type.result)}`;
+  }
+}
+
+// src/rslang/semantic/typification-api.ts
+var TypeIDToClass = {
+  [TypeID.anyTypification]: TypeClass.typification,
+  [TypeID.integer]: TypeClass.typification,
+  [TypeID.basic]: TypeClass.typification,
+  [TypeID.tuple]: TypeClass.typification,
+  [TypeID.collection]: TypeClass.typification,
+  [TypeID.logic]: TypeClass.logic,
+  [TypeID.function]: TypeClass.function,
+  [TypeID.predicate]: TypeClass.predicate
+};
+
+// src/rslang/semantic/value-class.ts
+var ValueClass = {
+  VALUE: "value",
+  PROPERTY: "property"
+};
+
+// src/library/rsform.ts
+var CstType = {
+  NOMINAL: "nominal",
+  BASE: "basic",
+  STRUCTURED: "structure",
+  TERM: "term",
+  AXIOM: "axiom",
+  FUNCTION: "function",
+  PREDICATE: "predicate",
+  CONSTANT: "constant",
+  STATEMENT: "statement"
+};
+var CstClass = {
+  NOMINAL: "nominal",
+  BASIC: "basic",
+  DERIVED: "derived",
+  STATEMENT: "statement",
+  TEMPLATE: "template"
+};
+var CstStatus = {
+  VERIFIED: "verified",
+  INCORRECT: "incorrect",
+  INCALCULABLE: "incalculable",
+  PROPERTY: "property",
+  UNKNOWN: "unknown"
+};
+
+// src/library/rsform-api.ts
+var CST_TYPE_PREFIX = {
+  [CstType.NOMINAL]: "N",
+  [CstType.BASE]: "X",
+  [CstType.CONSTANT]: "C",
+  [CstType.STRUCTURED]: "S",
+  [CstType.AXIOM]: "A",
+  [CstType.TERM]: "D",
+  [CstType.FUNCTION]: "F",
+  [CstType.PREDICATE]: "P",
+  [CstType.STATEMENT]: "T"
+};
+var CST_TYPE_TO_CLASS = {
+  [CstType.NOMINAL]: CstClass.NOMINAL,
+  [CstType.BASE]: CstClass.BASIC,
+  [CstType.CONSTANT]: CstClass.BASIC,
+  [CstType.STRUCTURED]: CstClass.BASIC,
+  [CstType.TERM]: CstClass.DERIVED,
+  [CstType.FUNCTION]: CstClass.DERIVED,
+  [CstType.AXIOM]: CstClass.STATEMENT,
+  [CstType.PREDICATE]: CstClass.DERIVED,
+  [CstType.STATEMENT]: CstClass.STATEMENT
+};
+function isBasicConcept(type) {
+  switch (type) {
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.AXIOM:
+      return true;
+    case CstType.TERM:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+    case CstType.STATEMENT:
+      return false;
+  }
+}
+function isBaseSet(type) {
+  switch (type) {
+    case CstType.BASE:
+    case CstType.CONSTANT:
+      return true;
+    case CstType.NOMINAL:
+    case CstType.STRUCTURED:
+    case CstType.AXIOM:
+    case CstType.TERM:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+    case CstType.STATEMENT:
+      return false;
+  }
+}
+function isFunctional(type) {
+  switch (type) {
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return true;
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.AXIOM:
+    case CstType.TERM:
+    case CstType.STATEMENT:
+      return false;
+  }
+}
+function typeClassForCstType(cstType) {
+  switch (cstType) {
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.TERM:
+      return TypeClass.typification;
+    case CstType.FUNCTION:
+      return TypeClass.function;
+    case CstType.PREDICATE:
+      return TypeClass.predicate;
+    case CstType.AXIOM:
+    case CstType.STATEMENT:
+      return TypeClass.logic;
+  }
+}
+function canHaveFormalDefinition(cstType) {
+  return cstType !== CstType.BASE && cstType !== CstType.CONSTANT;
+}
+function getAnalysisFor(expression, cstType, schema, alias) {
+  if (!canHaveFormalDefinition(cstType)) {
+    if (expression.trim().length === 0) {
+      const fallbackAlias = alias && alias.length > 0 ? alias : "X0";
+      const type = cstType === CstType.BASE ? bool(basic(fallbackAlias)) : bool(constant(fallbackAlias));
+      return {
+        success: true,
+        type,
+        valueClass: ValueClass.VALUE,
+        errors: [],
+        ast: null
+      };
+    }
+    return {
+      success: false,
+      type: null,
+      valueClass: null,
+      errors: [
+        {
+          code: RSErrorCode.definitionNotAllowed,
+          from: 0,
+          to: Math.max(0, expression.length - 1)
+        }
+      ],
+      ast: null
+    };
+  }
+  return schema.analyzer.checkFull(expression, {
+    expected: typeClassForCstType(cstType),
+    isDomain: cstType === CstType.STRUCTURED
+  });
+}
+
+// src/library/rsmodel.ts
+var TYPE_BASIC = "basic";
+var EvalStatus = {
+  NO_EVAL: 1,
+  // не вычисляется
+  NOT_PROCESSED: 2,
+  // Интерпретация не вычислялась
+  INVALID_DATA: 3,
+  // Неверные данные
+  EVAL_FAIL: 4,
+  // Ошибка при вычислении
+  AXIOM_FALSE: 5,
+  // Значение аксиомы = FALSE
+  EMPTY: 6,
+  // Значение пусто
+  HAS_DATA: 7
+  // Интерпретация вычислена и не пуста
+};
+var DEFAULT_VALUE_TEXT = "N/A";
+
+// src/library/rsmodel-api.ts
+function isInferrable(type) {
+  switch (type) {
+    case CstType.AXIOM:
+    case CstType.STATEMENT:
+    case CstType.TERM:
+      return true;
+    case CstType.NOMINAL:
+    case CstType.BASE:
+    case CstType.CONSTANT:
+    case CstType.STRUCTURED:
+    case CstType.FUNCTION:
+    case CstType.PREDICATE:
+      return false;
+  }
+}
+function inferEvalStatus(value, cstType, wasCalculated = true, isInvalid = false) {
+  if (isBaseSet(cstType) || cstType === CstType.STRUCTURED) {
+    if (isInvalid) {
+      return EvalStatus.INVALID_DATA;
+    }
+    if (value === null || Array.isArray(value) && value.length === 0) {
+      return EvalStatus.EMPTY;
+    }
+    return EvalStatus.HAS_DATA;
+  }
+  if (!isInferrable(cstType)) {
+    return EvalStatus.NO_EVAL;
+  }
+  if (!wasCalculated) {
+    return EvalStatus.NOT_PROCESSED;
+  }
+  if (value === null) {
+    return EvalStatus.EVAL_FAIL;
+  }
+  if (cstType === CstType.AXIOM && value !== VALUE_TRUE) {
+    return EvalStatus.AXIOM_FALSE;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return EvalStatus.EMPTY;
+  }
+  return EvalStatus.HAS_DATA;
+}
+function tryFixValue(value, type, targetAlias, targetValue) {
+  switch (type.typeID) {
+    case TypeID.integer:
+      return false;
+    case TypeID.basic:
+      if (type.baseID !== targetAlias) {
+        return false;
+      }
+      if (typeof value !== "number") {
+        return null;
+      }
+      if (!targetValue.includes(value)) {
+        return null;
+      }
+      return false;
+    case TypeID.tuple: {
+      if (!isTupleValue(value)) {
+        return null;
+      }
+      let wasChanged2 = false;
+      for (let i = 0; i < type.factors.length; i++) {
+        const componentChanged = tryFixValue(value[i + 1], type.factors[i], targetAlias, targetValue);
+        if (componentChanged === null) {
+          return null;
+        }
+        if (componentChanged) {
+          wasChanged2 = true;
+        }
+      }
+      return wasChanged2;
+    }
+    case TypeID.collection:
+      if (!Array.isArray(value) || value.length > 1 && value[0] === TUPLE_ID) {
+        return null;
+      }
+      let wasChanged = false;
+      const removeElements = [];
+      for (const item of value) {
+        const elementChanged = tryFixValue(item, type.base, targetAlias, targetValue);
+        if (elementChanged === null || elementChanged === true) {
+          wasChanged = true;
+          if (elementChanged === null) {
+            removeElements.push(item);
+          }
+        }
+      }
+      for (const item of removeElements) {
+        const index = value.indexOf(item);
+        if (index !== -1) {
+          value.splice(index, 1);
+        }
+      }
+      if (wasChanged) {
+        value.sort((a, b) => compare(a, b));
+        let i = 1;
+        while (i < value.length) {
+          if (compare(value[i], value[i - 1]) === 0) {
+            value.splice(i, 1);
+          } else {
+            i++;
+          }
+        }
+      }
+      return wasChanged;
+    case TypeID.logic:
+    case TypeID.anyTypification:
+    case TypeID.predicate:
+    case TypeID.function:
+      return null;
+  }
+}
+
+// src/library/rsengine.ts
+var INVALID_TYPE_MARKER = "INVALID";
+var RSEngine = class {
+  modelID;
+  schema = null;
+  data = null;
+  calculator = new RSCalculator();
+  basics = /* @__PURE__ */ new Map();
+  services;
+  notifications;
+  invalidData = /* @__PURE__ */ new Set();
+  calculatedSet = /* @__PURE__ */ new Set();
+  valueSubscribers = /* @__PURE__ */ new Map();
+  statusSubscribers = /* @__PURE__ */ new Map();
+  changeSubscribers = /* @__PURE__ */ new Set();
+  changeGeneration = 0;
+  pendingChange = false;
+  coalescedEmitTimeout = null;
+  constructor(modelID, services, notifications = null) {
+    this.services = services;
+    this.notifications = notifications;
+    this.modelID = modelID;
+  }
+  /** Updates data for {@link RSEngine}. */
+  loadData(schema, model) {
+    const oldSchema = this.schema;
+    const newSchema = oldSchema !== schema;
+    this.schema = schema;
+    if (newSchema) {
+      const changedCst = this.collectChanged(oldSchema, schema);
+      this.prepareAst();
+      this.setupEmptySets();
+      this.onChangeDefinitions(changedCst);
+    }
+    if (this.data !== model) {
+      this.data = model;
+      this.prepareValues();
+    }
+    this.notifyAll();
+  }
+  /** Updates services for {@link RSEngine}. */
+  updateServices(services) {
+    this.services = services;
+  }
+  /** Updates notifications for {@link RSEngine}. */
+  updateNotifications(notifications) {
+    this.notifications = notifications;
+  }
+  /** Gets value of {@link Constituenta}. */
+  getCstValue(cstID) {
+    const cst = this.schema?.cstByID.get(cstID);
+    if (!cst) {
+      return null;
+    }
+    return this.calculator.getValue(cst.alias);
+  }
+  /** Gets status of {@link Constituenta}. */
+  getCstStatus(cstID) {
+    const cst = this.schema?.cstByID.get(cstID);
+    if (!cst) {
+      return inferEvalStatus(null, CstType.NOMINAL, false);
+    }
+    const value = this.calculator.getValue(cst.alias);
+    return inferEvalStatus(value, cst.cst_type, this.calculatedSet.has(cstID), this.invalidData.has(cstID));
+  }
+  /** Subscribe to value change of {@link Constituenta}. */
+  subscribeValue(cstID, callbackFn) {
+    let subs = this.valueSubscribers.get(cstID);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.valueSubscribers.set(cstID, subs);
+    }
+    subs.add(callbackFn);
+    return () => {
+      const current = this.valueSubscribers.get(cstID);
+      if (!current) {
+        return;
+      }
+      current.delete(callbackFn);
+      if (current.size === 0) {
+        this.valueSubscribers.delete(cstID);
+      }
+    };
+  }
+  /** Subscribe to status change of {@link Constituenta}. */
+  subscribeStatus(cstID, callbackFn) {
+    let subs = this.statusSubscribers.get(cstID);
+    if (!subs) {
+      subs = /* @__PURE__ */ new Set();
+      this.statusSubscribers.set(cstID, subs);
+    }
+    subs.add(callbackFn);
+    return () => {
+      const current = this.statusSubscribers.get(cstID);
+      if (!current) {
+        return;
+      }
+      current.delete(callbackFn);
+      if (current.size === 0) {
+        this.statusSubscribers.delete(cstID);
+      }
+    };
+  }
+  /**
+   * Subscribe to any engine change that can affect evaluation (values, status, or loaded data).
+   */
+  subscribeChanges(callbackFn) {
+    this.changeSubscribers.add(callbackFn);
+    return () => {
+      this.changeSubscribers.delete(callbackFn);
+    };
+  }
+  /** Monotonic counter bumped whenever the engine emits a change to {@link RSEngine.subscribeChanges} listeners. */
+  getChangeGeneration() {
+    return this.changeGeneration;
+  }
+  /**
+   * Runs pending {@link RSEngine.subscribeChanges} notifications immediately and clears the coalescing queue.
+   * Use after a synchronous batch of engine updates when listeners must observe a bumped {@link getChangeGeneration}
+   * in the same turn.
+   */
+  flushPendingChanges() {
+    if (this.coalescedEmitTimeout !== null) {
+      clearTimeout(this.coalescedEmitTimeout);
+      this.coalescedEmitTimeout = null;
+    }
+    if (!this.pendingChange) {
+      return;
+    }
+    this.pendingChange = false;
+    this.emitChange();
+  }
+  /** Sets value for {@link Constituenta} from {@link Value}. */
+  async setStructureValue(cstID, data) {
+    const cst = this.schema?.cstByID.get(cstID);
+    if (!this.schema || !cst || isInferrable(cst.cst_type)) {
+      this.notifications?.onInvalidSetValue();
+      return;
+    }
+    const typeStr = cst.effectiveType ? normalizeType(cst.effectiveType) : INVALID_TYPE_MARKER;
+    const payload = [{ target: cstID, type: typeStr, data }];
+    await this.services.setCstValue({ itemID: this.modelID, data: payload });
+    if (!cst.effectiveType || !this.calculator.validate(data, cst.effectiveType)) {
+      this.invalidData.add(cstID);
+    } else {
+      this.invalidData.delete(cstID);
+    }
+    this.calculator.setValue(cst.alias, data);
+    this.notifyCst(cstID);
+    this.cascadeReset([cstID]);
+  }
+  /** Sets value for {@link Constituenta} from {@link BasicBinding}. */
+  async setBasicValue(cstID, data) {
+    const cst = this.schema?.cstByID.get(cstID);
+    if (!this.schema || !cst || !isBaseSet(cst.cst_type)) {
+      this.notifications?.onInvalidSetValue();
+      return;
+    }
+    const oldValue = this.calculator.getValue(cst.alias);
+    const newValue = Object.keys(data).map(Number);
+    const updateList = [
+      { target: cstID, type: TYPE_BASIC, data }
+    ];
+    const resetList = [];
+    if (oldValue !== null && compare(newValue, oldValue) !== 0) {
+      const dependencies = this.schema.graph.expandAllOutputs([cstID]);
+      for (const childID of dependencies) {
+        const child = this.schema.cstByID.get(childID);
+        if (child.cst_type === CstType.STRUCTURED && !!child.effectiveType) {
+          const value = this.calculator.getValue(child.alias);
+          if (value !== null) {
+            const fix = tryFixValue(value, child.effectiveType, cst.alias, newValue);
+            if (fix === null) {
+              resetList.push(childID);
+            } else if (fix === true) {
+              const typeStr = normalizeType(child.effectiveType);
+              updateList.push({ target: childID, type: typeStr, data: [...value] });
+            }
+          }
+        }
+      }
+    }
+    if (resetList.length > 0) {
+      await Promise.all([
+        this.services.setCstValue({ itemID: this.modelID, data: updateList }),
+        this.services.clearValues({ itemID: this.modelID, data: { items: resetList } })
+      ]);
+    } else {
+      await this.services.setCstValue({ itemID: this.modelID, data: updateList });
+    }
+    const changed = [...resetList, ...updateList.map((item) => item.target)];
+    this.basics.set(cstID, data);
+    this.calculator.setValue(cst.alias, Object.keys(data).map(Number));
+    for (const item of resetList) {
+      this.calculator.resetValue(this.schema.cstByID.get(item).alias);
+      this.notifyCst(item);
+    }
+    for (const updateData of updateList) {
+      if (updateData.target !== cstID) {
+        this.calculator.setValue(
+          this.schema.cstByID.get(updateData.target).alias,
+          updateData.data
+        );
+        this.notifyCst(updateData.target);
+      }
+    }
+    for (const item of changed) {
+      this.notifyCst(item);
+    }
+    this.cascadeReset(changed);
+  }
+  /** Resets value for {@link Constituenta}. */
+  async resetValue(cstID) {
+    const cst = this.schema?.cstByID.get(cstID);
+    if (!cst) {
+      return;
+    }
+    await this.services.clearValues({ itemID: this.modelID, data: { items: [cstID] } });
+    this.calculator.resetValue(cst.alias);
+    this.basics.delete(cstID);
+    this.calculatedSet.delete(cstID);
+    this.invalidData.delete(cstID);
+    this.notifyCst(cstID);
+  }
+  /** Evaluates expression for {@link RSEngine}. */
+  evaluateExpression(expression, cstType) {
+    return getEvaluationFor(
+      expression,
+      cstType,
+      this.schema,
+      this.calculator,
+      (message) => this.notifications?.onEvaluationError(message)
+    );
+  }
+  /** Evaluates AST for {@link RSEngine}. */
+  evaluateAst(ast, options) {
+    try {
+      const evaluation = this.calculator.evaluateFull(ast, options);
+      return evaluation;
+    } catch (error) {
+      this.notifications?.onEvaluationError(error.message);
+      console.error(error);
+      return {
+        value: null,
+        iterations: 0,
+        cacheHits: 0,
+        errors: []
+      };
+    }
+  }
+  /** Calculates value for {@link Constituenta}. */
+  calculateCst(cstID) {
+    const cst = this.schema?.cstByID.get(cstID);
+    if (!cst || !this.schema) {
+      return { value: null, iterations: 0, errors: [], cacheHits: 0 };
+    }
+    if (!this.calculatedSet.has(cstID)) {
+      const predecessors = this.schema.graph.expandAllInputs([cstID]);
+      this.prepareEvaluation(predecessors);
+    }
+    const result = getEvaluationFor(
+      cst.definition_formal,
+      cst.cst_type,
+      this.schema,
+      this.calculator,
+      (message) => this.notifications?.onEvaluationError(message)
+    );
+    if (result.value === null) {
+      this.calculator.resetValue(cst.alias);
+    } else {
+      this.calculator.setValue(cst.alias, result.value);
+    }
+    this.calculatedSet.add(cstID);
+    this.notifyCst(cstID);
+    return result;
+  }
+  /** Recalculate model for all inferrable expressions. */
+  recalculateAll() {
+    const start = performance.now();
+    this.calculatedSet.clear();
+    this.recalculateInternal();
+    const end = performance.now();
+    const timeSpent = ((end - start) / 1e3).toFixed(2);
+    this.notifications?.onCalculationSuccess(timeSpent);
+  }
+  /** Notify subscribers about value and status change of {@link Constituenta}. */
+  notifyCst(cstID) {
+    this.notifyStatus(cstID);
+    this.notifyValue(cstID);
+    this.scheduleCoalescedEmitChange();
+  }
+  /** Notify all subscribers about value change. */
+  notifyValue(cstID) {
+    const subs = this.valueSubscribers.get(cstID);
+    if (subs) {
+      for (const cb of subs) cb();
+    }
+  }
+  /** Notify all subscribers about status change. */
+  notifyStatus(cstID) {
+    const subs = this.statusSubscribers.get(cstID);
+    if (subs) {
+      for (const cb of subs) cb();
+    }
+  }
+  /** Notify all subscribers about value and status change. */
+  notifyAll() {
+    for (const subs of this.valueSubscribers.values()) {
+      for (const cb of subs) cb();
+    }
+    for (const subs of this.statusSubscribers.values()) {
+      for (const cb of subs) cb();
+    }
+    this.scheduleCoalescedEmitChange();
+  }
+  scheduleCoalescedEmitChange() {
+    this.pendingChange = true;
+    if (this.coalescedEmitTimeout !== null) {
+      return;
+    }
+    this.coalescedEmitTimeout = setTimeout(
+      function runCoalescedEmitChange() {
+        this.coalescedEmitTimeout = null;
+        if (!this.pendingChange) {
+          return;
+        }
+        this.pendingChange = false;
+        this.emitChange();
+      }.bind(this),
+      0
+    );
+  }
+  emitChange() {
+    this.changeGeneration += 1;
+    for (const cb of this.changeSubscribers) {
+      cb();
+    }
+  }
+  prepareAst() {
+    this.calculator.clearAllAst();
+    const functions = this.schema.items.filter((cst) => isFunctional(cst.cst_type) && cst.analysis?.success);
+    for (const cst of functions) {
+      const fullAnalysis = getAnalysisFor(cst.definition_formal, cst.cst_type, this.schema);
+      if (fullAnalysis.ast) {
+        this.calculator.setAST(cst.alias, fullAnalysis.ast);
+      }
+    }
+  }
+  prepareValues() {
+    this.basics.clear();
+    this.invalidData.clear();
+    this.calculatedSet.clear();
+    for (const item of this.data.items) {
+      const cst = this.schema.cstByID.get(item.id);
+      if (item.type === TYPE_BASIC) {
+        if (cst.cst_type !== CstType.BASE && cst.cst_type !== CstType.CONSTANT) {
+          throw new Error(`Invalid data for ${cst.alias}`);
+        }
+        const data = item.value;
+        this.basics.set(cst.id, data);
+        this.calculator.setValue(cst.alias, Object.keys(data).map(Number));
+      }
+    }
+    for (const item of this.data.items) {
+      const cst = this.schema.cstByID.get(item.id);
+      if (item.type !== TYPE_BASIC) {
+        this.calculator.setValue(cst.alias, item.value);
+        if (!cst.effectiveType || !this.calculator.validate(item.value, cst.effectiveType)) {
+          this.invalidData.add(item.id);
+        }
+      }
+    }
+    this.setupEmptySets();
+  }
+  setupEmptySets() {
+    for (const cst of this.schema.items) {
+      if (isBasicConcept(cst.cst_type) && this.schema.analyzer.getType(cst.alias)?.typeID === TypeID.collection) {
+        if (this.calculator.getValue(cst.alias) === null) {
+          this.calculator.setValue(cst.alias, []);
+        }
+      }
+    }
+  }
+  collectChanged(previousSchema, nextSchema) {
+    if (!previousSchema) {
+      return [];
+    }
+    const changedIDs = [];
+    for (const cst of nextSchema.items) {
+      const prev = previousSchema.cstByID.get(cst.id);
+      if (prev && (prev.definition_formal !== cst.definition_formal || prev.alias !== cst.alias)) {
+        changedIDs.push(cst.id);
+      }
+    }
+    return changedIDs;
+  }
+  onChangeDefinitions(cstIDs) {
+    if (!this.schema || cstIDs.length === 0) {
+      return;
+    }
+    for (const cstID of cstIDs) {
+      const cst = this.schema.cstByID.get(cstID);
+      if (!cst || !isInferrable(cst.cst_type)) {
+        continue;
+      }
+      this.calculatedSet.delete(cstID);
+      this.calculator.resetValue(cst.alias);
+      this.notifyCst(cstID);
+    }
+    this.cascadeReset(cstIDs);
+  }
+  cascadeReset(cstIDs) {
+    if (!this.schema) {
+      return;
+    }
+    const dependencies = this.schema.graph.expandAllOutputs(cstIDs);
+    for (const cstID of dependencies) {
+      const cst = this.schema.cstByID.get(cstID);
+      if (!cst || !isInferrable(cst.cst_type)) {
+        continue;
+      }
+      this.calculatedSet.delete(cstID);
+      this.calculator.resetValue(this.schema.cstByID.get(cstID).alias);
+      this.notifyCst(cstID);
+    }
+  }
+  prepareEvaluation(dependencies) {
+    for (const cstID of this.schema.graph.topologicalOrder()) {
+      if (dependencies.includes(cstID)) {
+        const cst = this.schema.cstByID.get(cstID);
+        if (isInferrable(cst.cst_type)) {
+          const value = fastEvaluation(
+            cst.definition_formal,
+            cst.cst_type,
+            this.schema,
+            this.calculator,
+            (message) => this.notifications?.onEvaluationError(message)
+          );
+          if (value !== null) {
+            this.calculator.setValue(cst.alias, value);
+          } else {
+            this.calculator.resetValue(cst.alias);
+          }
+          this.notifyCst(cstID);
+        }
+        this.calculatedSet.add(cstID);
+      }
+    }
+  }
+  recalculateInternal() {
+    const processedIDs = [];
+    for (const cst of this.schema.cstByID.values()) {
+      if (isInferrable(cst.cst_type)) {
+        this.calculator.resetValue(cst.alias);
+      }
+    }
+    for (const cstID of this.schema.graph.topologicalOrder()) {
+      processedIDs.push(cstID);
+      const cst = this.schema.cstByID.get(cstID);
+      if (isInferrable(cst.cst_type)) {
+        const value = fastEvaluation(cst.definition_formal, cst.cst_type, this.schema, this.calculator);
+        this.calculatedSet.add(cstID);
+        if (value !== null) {
+          this.calculator.setValue(cst.alias, value);
+        }
+      }
+    }
+    this.notifyAll();
+  }
+};
+function getEvaluationFor(expression, cstType, schema, calculator, onEvaluationError) {
+  const parse = getAnalysisFor(expression, cstType, schema);
+  if (!parse.success || !parse.ast) {
+    return {
+      value: null,
+      iterations: 0,
+      cacheHits: 0,
+      errors: parse.errors
+    };
+  } else {
+    try {
+      const result = calculator.evaluateFull(parse.ast);
+      return {
+        value: result.value,
+        iterations: result.iterations,
+        cacheHits: result.cacheHits,
+        errors: [...parse.errors, ...result.errors]
+      };
+    } catch (error) {
+      onEvaluationError?.(error.message);
+      console.error(expression, error);
+      return {
+        value: null,
+        iterations: 0,
+        cacheHits: 0,
+        errors: []
+      };
+    }
+  }
+}
+function fastEvaluation(expression, cstType, schema, calculator, onEvaluationError) {
+  const parse = getAnalysisFor(expression, cstType, schema);
+  if (!parse.success || !parse.ast) {
+    return null;
+  } else {
+    try {
+      return calculator.evaluateFast(parse.ast);
+    } catch (error) {
+      onEvaluationError?.(error.message);
+      console.error(expression, error);
+      return null;
+    }
+  }
+}
+export {
+  AccessPolicy,
+  CstClass,
+  CstStatus,
+  CstType,
+  DEFAULT_VALUE_TEXT,
+  EvalStatus,
+  FolderNode,
+  FolderTree,
+  LibraryItemType,
+  LocationHead,
+  NodeType,
+  OperationType,
+  RSEngine,
+  SubstitutionErrorType
+};
+//# sourceMappingURL=index.js.map