@rsconcept/domain 1.0.0 → 1.1.0

package/dist/rslang/index.js

@@ -1,4314 +1,12 @@
-// src/rslang/ast-annotations.ts
-var AST_ERRORS_KEY = "rsErrors";
-var AST_TYPE_KEY = "rsType";
-function annotateType(node, type) {
-  node.annotation = {
-    ...typeof node.annotation === "object" && node.annotation !== null ? node.annotation : {},
-    [AST_TYPE_KEY]: type
-  };
-}
-function readTypeAnnotation(node) {
-  if (node.annotation && AST_TYPE_KEY in node.annotation) {
-    return node.annotation[AST_TYPE_KEY];
-  }
-  return null;
-}
-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 readErrorAnnotation(node) {
-  const raw = node.annotation?.[AST_ERRORS_KEY];
-  if (isAstNodeErrorRef(raw)) {
-    return raw;
-  }
-  return null;
-}
-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 buildTree(cursor) {
-  let nextUid = 1;
-  function genUid() {
-    return nextUid++;
-  }
-  return buildTreeInternal(cursor, null, genUid);
-}
-function visitAstDFS(node, callback) {
-  for (const child of node.children) {
-    visitAstDFS(child, callback);
-  }
-  callback(node);
-}
-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 [];
-}
-function buildTreeInternal(cursor, parent = null, genUid) {
-  const node = cursor.node;
-  const result = {
-    uid: genUid(),
-    typeID: node.type.isError ? 0 : node.type.id,
-    from: node.from,
-    to: node.to,
-    hasError: node.type.isError,
-    data: node.type.isError ? { dataType: "null", value: null } : { dataType: "string", value: node.type.name },
-    parent,
-    children: []
-  };
-  if (cursor.firstChild()) {
-    do {
-      const child = buildTreeInternal(cursor, result, genUid);
-      if (child.hasError) {
-        result.hasError = true;
-      }
-      result.children.push(child);
-    } while (cursor.nextSibling());
-    cursor.parent();
-  }
-  return result;
-}
-
-// 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
-};
-function makeTypePath(path) {
-  return path;
-}
-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 };
-}
-function tuple(factors) {
-  if (factors.length < 2) {
-    throw new Error("Tuple with less than two factors is not allowed");
-  }
-  return { typeID: TypeID.tuple, factors };
-}
-function debool(target) {
-  return target.base;
-}
-function component(target, index) {
-  return target.factors[index - 1] ?? null;
-}
-function isTypification(type) {
-  return type?.typeID === TypeID.basic || type?.typeID === TypeID.anyTypification || type?.typeID === TypeID.integer || type?.typeID === TypeID.collection || type?.typeID === TypeID.tuple;
-}
-function isRadical(alias) {
-  return alias.length > 0 && alias.startsWith("R") && alias[1] !== "0";
-}
-
-// 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(tuple2);
-}
-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] : tuple2(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 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;
-function makeValuePath(path) {
-  return path;
-}
-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 tuple2(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 tuple2(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] : tuple2(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] : tuple2(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 Expression = 1;
-var Logic = 2;
-var Logic_predicates = 3;
-var Variable = 4;
-var Local = 5;
-var Tuple = 8;
-var Expr_enum_min2 = 9;
-var Logic_unary = 24;
-var Predicate = 26;
-var Logic_quantor = 29;
-var Variable_pack = 31;
-var Logic_binary = 33;
-var Setexpr = 38;
-var Integer = 39;
-var EmptySet = 40;
-var IntegerSet = 41;
-var Global = 42;
-var Radical = 43;
-var Setexpr_binary = 44;
-var Enumeration = 55;
-var Boolean = 56;
-var Filter_expression = 58;
-var Filter = 59;
-var Declarative = 60;
-var PrefixD = 62;
-var Imperative = 64;
-var Imp_blocks = 65;
-var Recursion = 68;
-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
-function normalizeAST(ast, input) {
-  visitAstDFS(ast, (node) => normalizeNode(node, input));
-}
-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
-};
-function normalizeNode(node, input) {
-  if (node.hasError) {
-    return;
-  }
-  switch (node.typeID) {
-    case 0:
-      return;
-    case Expression:
-      promoteSingleChild(node);
-      return;
-    case EmptySet:
-    case IntegerSet:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      return;
-    case Integer:
-      node.typeID = idRecord[node.typeID];
-      node.data.dataType = "number";
-      node.data.value = Number(input.slice(node.from, node.to));
-      return;
-    case Function:
-    case Predicate:
-    case Global:
-    case Local:
-    case Radical:
-    case Integer:
-      node.typeID = idRecord[node.typeID];
-      node.data.dataType = "string";
-      node.data.value = input.slice(node.from, node.to);
-      return;
-    case Boolean:
-      node.typeID = idRecord[node.typeID];
-      if (node.children.length === 4) {
-        node.children = [node.children[2]];
-      } else {
-        node.children = [node.children[1]];
-      }
-      clearData(node);
-      return;
-    case Filter:
-    case BigPr:
-    case SmallPr:
-      node.typeID = idRecord[node.typeID];
-      node.data.dataType = "string[]";
-      node.data.value = parseIndex(input.slice(node.from + 2, node.to));
-      return;
-    case Red:
-    case Debool:
-    case Bool:
-    case Card:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      return;
-    case Function_decl:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      node.children = [node.children[1], node.children[3]];
-      return;
-    case Declaration:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      node.children = [node.children[0], node.children[2]];
-      return;
-    case Arguments:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      if (node.children.length === 3) {
-        processLeftEnum(node);
-      }
-      return;
-    case Expr_enum_min2:
-      processLeftEnum(node);
-      return;
-    case Setexpr:
-      if (node.children.length === 1) {
-        promoteSingleChild(node);
-      } else if (node.children.length === 4) {
-        processTextFunction(node);
-      }
-      return;
-    case Tuple:
-    case Enumeration:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      if (node.children[1].typeID === Expr_enum_min2) {
-        for (const child of node.children[1].children) {
-          child.parent = node;
-        }
-        node.children = node.children[1].children;
-      } else {
-        node.children = [node.children[1]];
-      }
-      return;
-    case Logic_binary:
-    case Logic_predicates:
-    case Setexpr_binary:
-      if (node.children[0].data.value === "(") {
-        processParenthesis(node);
-      } else {
-        clearData(node);
-        node.typeID = symbolToToken(node.children[1].data.value);
-        if (node.typeID === TokenID.DECART) {
-          processDecartChildren(node);
-        } else {
-          node.children = [node.children[0], node.children[2]];
-        }
-      }
-      return;
-    case Filter_expression:
-      processFilter(node);
-      return;
-    case Logic:
-      if (node.children[0].data.value === "(") {
-        processParenthesis(node);
-      } else {
-        promoteSingleChild(node);
-      }
-      return;
-    case Logic_unary:
-      if (node.children[0].data.value === "\xAC") {
-        clearData(node);
-        node.typeID = TokenID.LOGIC_NOT;
-        node.children = [node.children[1]];
-      } else if (node.children[0].typeID === TokenID.ID_PREDICATE) {
-        processTextFunction(node);
-      } else {
-        promoteSingleChild(node);
-      }
-      return;
-    case Logic_quantor:
-      clearData(node);
-      node.typeID = symbolToToken(node.children[0].data.value);
-      node.children = [node.children[1], node.children[3], node.children[4]];
-      return;
-    case Variable:
-      convertTupleDeclaration(node.children[0]);
-      promoteSingleChild(node);
-      return;
-    case Variable_pack:
-      if (node.children.length === 1) {
-        promoteSingleChild(node);
-      } else {
-        node.typeID = idRecord[node.typeID];
-        processLeftEnum(node);
-      }
-      return;
-    case Declarative:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      if (node.children[0].typeID === PrefixD) {
-        node.children = [node.children[2], node.children[4], node.children[6]];
-      } else {
-        node.children = [node.children[1], node.children[3], node.children[5]];
-      }
-      return;
-    case Imp_blocks:
-      if (node.children.length === 1) {
-        if (node.parent?.typeID === Imp_blocks) {
-          promoteSingleChild(node);
-        }
-      } else {
-        processLeftEnum(node);
-      }
-      return;
-    case Imperative:
-      node.typeID = idRecord[node.typeID];
-      clearData(node);
-      for (const child of node.children[4].children) {
-        child.parent = node;
-      }
-      node.children = [node.children[2], ...node.children[4].children];
-      return;
-    case Recursion:
-      if (node.children.length > 9) {
-        node.typeID = TokenID.NT_RECURSIVE_FULL;
-        node.children = [node.children[2], node.children[4], node.children[6], node.children[8]];
-      } else {
-        node.typeID = TokenID.NT_RECURSIVE_SHORT;
-        node.children = [node.children[2], node.children[4], node.children[6]];
-      }
-      return;
-  }
-}
-function convertTupleDeclaration(node) {
-  if (node.typeID !== TokenID.NT_TUPLE) {
-    return;
-  }
-  node.typeID = TokenID.NT_TUPLE_DECL;
-  for (const child of node.children) {
-    convertTupleDeclaration(child);
-  }
-}
-function clearData(node) {
-  node.data.value = null;
-  node.data.dataType = "null";
-}
-function promoteSingleChild(node, index = 0) {
-  for (const child of node.children[index].children) {
-    child.parent = node;
-  }
-  node.typeID = node.children[index].typeID;
-  node.data = node.children[index].data;
-  node.parenthesis = node.children[index].parenthesis;
-  node.children = node.children[index].children;
-}
-function parseIndex(text) {
-  return text.split(",");
-}
-function symbolToToken(symbol) {
-  switch (symbol) {
-    case "+":
-      return TokenID.PLUS;
-    case "-":
-      return TokenID.MINUS;
-    case "*":
-      return TokenID.MULTIPLY;
-    case "\u222A":
-      return TokenID.SET_UNION;
-    case "\\":
-      return TokenID.SET_MINUS;
-    case "\u2206":
-      return TokenID.SET_SYMMETRIC_MINUS;
-    case "\u2229":
-      return TokenID.SET_INTERSECTION;
-    case "\xD7":
-      return TokenID.DECART;
-    case "\u2208":
-      return TokenID.SET_IN;
-    case "\u2209":
-      return TokenID.SET_NOT_IN;
-    case "\u2286":
-      return TokenID.SUBSET_OR_EQ;
-    case "\u2284":
-      return TokenID.NOT_SUBSET;
-    case "\u2282":
-      return TokenID.SUBSET;
-    case ">":
-      return TokenID.GREATER;
-    case "\u2265":
-      return TokenID.GREATER_OR_EQ;
-    case "<":
-      return TokenID.LESSER;
-    case "\u2264":
-      return TokenID.LESSER_OR_EQ;
-    case "\u2260":
-      return TokenID.NOTEQUAL;
-    case "=":
-      return TokenID.EQUAL;
-    case ":\u2208":
-      return TokenID.ITERATE;
-    case ":=":
-      return TokenID.ASSIGN;
-    case "\xAC":
-      return TokenID.LOGIC_NOT;
-    case "\u21D4":
-      return TokenID.LOGIC_EQUIVALENT;
-    case "\u21D2":
-      return TokenID.LOGIC_IMPLICATION;
-    case "\u2228":
-      return TokenID.LOGIC_OR;
-    case "&":
-      return TokenID.LOGIC_AND;
-    case "\u2200":
-      return TokenID.QUANTOR_UNIVERSAL;
-    case "\u2203":
-      return TokenID.QUANTOR_EXISTS;
-  }
-  return TokenID.ERROR;
-}
-function processParenthesis(node) {
-  promoteSingleChild(node, 1);
-  node.parenthesis = true;
-}
-function processLeftEnum(node) {
-  if (node.children[0].typeID === node.typeID) {
-    for (const child of node.children[0].children) {
-      child.parent = node;
-    }
-    node.children = [...node.children[0].children, node.children[2]];
-  } else {
-    node.children = [node.children[0], node.children[2]];
-  }
-}
-function processDecartChildren(node) {
-  const newChildren = [];
-  if (node.children[0].typeID === TokenID.DECART && !node.children[0].parenthesis) {
-    for (const child of node.children[0].children) {
-      child.parent = node;
-      newChildren.push(child);
-    }
-  } else {
-    newChildren.push(node.children[0]);
-  }
-  if (node.children[2].typeID === TokenID.DECART && !node.children[2].parenthesis) {
-    for (const child of node.children[2].children) {
-      child.parent = node;
-      newChildren.push(child);
-    }
-  } else {
-    newChildren.push(node.children[2]);
-  }
-  node.children = newChildren;
-}
-function processTextFunction(node) {
-  if (node.children[0].typeID === TokenID.ID_FUNCTION || node.children[0].typeID === TokenID.ID_PREDICATE) {
-    node.typeID = TokenID.NT_FUNC_CALL;
-    clearData(node);
-    if (node.children[2].typeID === Expr_enum_min2) {
-      for (const child of node.children[2].children) {
-        child.parent = node;
-      }
-      node.children = [node.children[0], ...node.children[2].children];
-    } else {
-      node.children = [node.children[0], node.children[2]];
-    }
-  } else {
-    node.typeID = node.children[0].typeID;
-    node.data = node.children[0].data;
-    node.children = [node.children[2]];
-  }
-}
-function processFilter(node) {
-  const children = [];
-  if (node.children[2].typeID === Expr_enum_min2) {
-    for (const child of node.children[2].children) {
-      child.parent = node;
-      children.push(child);
-    }
-  } else {
-    children.push(node.children[2]);
-  }
-  children.push(node.children[5]);
-  promoteSingleChild(node);
-  node.children = children;
-}
-
-// src/rslang/parser/syntax-errors.ts
-function extractSyntaxErrors(ast, expression, reporter, annotateErrors = false) {
-  const bracketError = extractBracketErrors(expression);
-  if (bracketError !== null) {
-    reporter(bracketError);
-    if (annotateErrors) {
-      annotateError(ast, bracketError.code, bracketError.params);
-    }
-  }
-  const hasBracketErrors = bracketError !== null;
-  visitAstDFS(ast, (node) => extractInternal(node, reporter, annotateErrors, hasBracketErrors));
-}
-function extractInternal(node, reporter, annotateErrors, ignoreUnknownErrors) {
-  if (node.typeID !== TokenID.ERROR) {
-    return;
-  }
-  function emit(target, code) {
-    reporter({ code, from: target.from, to: target.to });
-    if (annotateErrors) {
-      annotateError(target, code);
-    }
-  }
-  const parent = node.parent;
-  if (parent === null) {
-    if (!ignoreUnknownErrors) {
-      return emit(node, RSErrorCode.unknownSyntax);
-    }
-    return;
-  }
-  if (parent.typeID === Variable) {
-    return emit(parent, RSErrorCode.expectedLocal);
-  }
-  if (!ignoreUnknownErrors) {
-    emit(node.from === node.to ? parent : node, RSErrorCode.unknownSyntax);
-  }
-}
-function extractBracketErrors(expression) {
-  const stack = [];
-  for (let pos = 0; pos < expression.length; pos++) {
-    const symbol = expression[pos];
-    if (isOpenBracket(symbol)) {
-      if (isDoubleParenthesis(expression, pos)) {
-        return {
-          code: RSErrorCode.doubleParenthesis,
-          from: pos,
-          to: pos + 2
-        };
-      }
-      stack.push({ bracket: symbol, index: pos });
-      continue;
-    }
-    if (!isCloseBracket(symbol)) {
-      continue;
-    }
-    const expectedOpen = closeToOpen(symbol);
-    const top = stack[stack.length - 1];
-    if (top === void 0) {
-      return {
-        code: RSErrorCode.missingOpenBracket,
-        from: pos,
-        to: pos + 1,
-        params: [expectedOpen]
-      };
-    }
-    if (top.bracket !== expectedOpen) {
-      return {
-        code: RSErrorCode.bracketMismatch,
-        from: pos,
-        to: pos + 1,
-        params: [openToClose(top.bracket), symbol]
-      };
-    }
-    stack.pop();
-  }
-  if (stack.length > 0) {
-    const unclosed = stack[0];
-    const code = missingBracketCode(unclosed.bracket);
-    return {
-      code,
-      from: expression.length,
-      to: expression.length
-    };
-  }
-  return null;
-}
-function missingBracketCode(bracket) {
-  switch (bracket) {
-    case "(":
-      return RSErrorCode.missingParenthesis;
-    case "[":
-      return RSErrorCode.missingSquareBracket;
-    case "{":
-      return RSErrorCode.missingCurlyBrace;
-  }
-}
-function isOpenBracket(symbol) {
-  return symbol === "(" || symbol === "[" || symbol === "{";
-}
-function isCloseBracket(symbol) {
-  return symbol === ")" || symbol === "]" || symbol === "}";
-}
-function openToClose(symbol) {
-  switch (symbol) {
-    case "(":
-      return ")";
-    case "[":
-      return "]";
-    case "{":
-      return "}";
-  }
-}
-function closeToOpen(symbol) {
-  switch (symbol) {
-    case ")":
-      return "(";
-    case "]":
-      return "[";
-    case "}":
-      return "{";
-  }
-}
-function isDoubleParenthesis(expression, pos) {
-  const isOpenDoubleParenthesis = expression[pos] === "(" && expression[pos + 1] === "(";
-  if (!isOpenDoubleParenthesis) {
-    return false;
-  }
-  const outerClose = findMatchingCloseBracket(expression, pos);
-  const innerClose = findMatchingCloseBracket(expression, pos + 1);
-  if (outerClose < 0 || innerClose < 0) {
-    return false;
-  }
-  return outerClose === innerClose + 1;
-}
-function findMatchingCloseBracket(expression, openPos) {
-  if (expression[openPos] !== "(") {
-    return -1;
-  }
-  const stack = [];
-  for (let index = openPos; index < expression.length; index++) {
-    const symbol = expression[index];
-    if (isOpenBracket(symbol)) {
-      stack.push(symbol);
-      continue;
-    }
-    if (!isCloseBracket(symbol)) {
-      continue;
-    }
-    const top = stack.pop();
-    if (top === void 0 || top !== closeToOpen(symbol)) {
-      return -1;
-    }
-    if (stack.length === 0) {
-      return index;
-    }
-  }
-  return -1;
-}
-
-// src/rslang/labels.ts
-var INTEGER_TYPE_NAME = "Z";
-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 labelToken(id) {
-  const text = labelTokenRecord[id];
-  return text ?? "UNKNOWN TOKEN: " + String(id);
-}
-function labelRSLangNode(node) {
-  switch (node.typeID) {
-    case TokenID.ERROR:
-      return "[ERROR]";
-    case TokenID.ID_LOCAL:
-    case TokenID.ID_GLOBAL:
-    case TokenID.ID_FUNCTION:
-    case TokenID.ID_PREDICATE:
-    case TokenID.ID_RADICAL:
-      return node.data.value;
-    case TokenID.LIT_INTEGER:
-      return String(node.data.value);
-    case TokenID.BIGPR:
-      return "Pr" + node.data.value.toString();
-    case TokenID.SMALLPR:
-      return "pr" + node.data.value.toString();
-    case TokenID.FILTER:
-      return "Fi" + node.data.value.toString();
-    case TokenID.NT_DECLARATIVE_EXPR:
-      return "DECLARATIVE";
-    case TokenID.NT_IMPERATIVE_EXPR:
-      return "IMPERATIVE";
-    case TokenID.NT_RECURSIVE_FULL:
-      return "RECURSIVE";
-    case TokenID.NT_RECURSIVE_SHORT:
-      return "RECURSIVE";
-    case TokenID.BOOLEAN:
-      return "\u212C";
-    case TokenID.REDUCE:
-      return "red";
-    case TokenID.CARD:
-      return "card";
-    case TokenID.BOOL:
-      return "bool";
-    case TokenID.DEBOOL:
-      return "debool";
-    case TokenID.PLUS:
-      return "+";
-    case TokenID.MINUS:
-      return "-";
-    case TokenID.MULTIPLY:
-      return "*";
-    case TokenID.GREATER:
-      return ">";
-    case TokenID.LESSER:
-      return "<";
-    case TokenID.NT_TUPLE:
-      return "TUPLE";
-    case TokenID.NT_ENUMERATION:
-      return "ENUM";
-    case TokenID.NT_ENUM_DECL:
-      return "ENUM_DECLARE";
-    case TokenID.NT_TUPLE_DECL:
-      return "TUPLE_DECLARE";
-    case TokenID.PUNCTUATION_DEFINE:
-      return "DEFINITION";
-    case TokenID.PUNCTUATION_STRUCT:
-      return "STRUCTURE_DEFINE";
-    case TokenID.NT_ARG_DECL:
-      return "ARG";
-    case TokenID.NT_FUNC_CALL:
-      return "CALL";
-    case TokenID.NT_ARGUMENTS:
-      return "ARGS";
-    case TokenID.NT_FUNC_DEFINITION:
-      return "FUNCTION_DEFINE";
-    case TokenID.DECART:
-    case TokenID.QUANTOR_UNIVERSAL:
-    case TokenID.QUANTOR_EXISTS:
-    case TokenID.LOGIC_NOT:
-    case TokenID.LOGIC_AND:
-    case TokenID.LOGIC_OR:
-    case TokenID.LOGIC_IMPLICATION:
-    case TokenID.LOGIC_EQUIVALENT:
-    case TokenID.LIT_EMPTYSET:
-    case TokenID.LIT_WHOLE_NUMBERS:
-    case TokenID.EQUAL:
-    case TokenID.NOTEQUAL:
-    case TokenID.GREATER_OR_EQ:
-    case TokenID.LESSER_OR_EQ:
-    case TokenID.SET_IN:
-    case TokenID.SET_NOT_IN:
-    case TokenID.SUBSET_OR_EQ:
-    case TokenID.SUBSET:
-    case TokenID.NOT_SUBSET:
-    case TokenID.SET_INTERSECTION:
-    case TokenID.SET_UNION:
-    case TokenID.SET_MINUS:
-    case TokenID.SET_SYMMETRIC_MINUS:
-    case TokenID.ASSIGN:
-    case TokenID.ITERATE:
-      return labelToken(node.typeID);
-  }
-  if (node.data.value) {
-    return node.data.value;
-  }
-  return "UNKNOWN NODE: " + String(node.typeID);
-}
-function labelType(type) {
-  if (!type) {
-    return "N/A";
-  }
-  switch (type.typeID) {
-    case TypeID.anyTypification:
-      return ANY_TYPE_NAME;
-    case TypeID.integer:
-      return INTEGER_TYPE_NAME;
-    case TypeID.basic:
-      return type.baseID;
-    case TypeID.tuple:
-      return type.factors.map((factor) => factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)).join("\xD7");
-    case TypeID.collection:
-      return type.base.typeID === TypeID.collection ? `\u212C${labelType(type.base)}` : `\u212C(${labelType(type.base)})`;
-    case TypeID.logic:
-      return LOGIC_TYPE_NAME;
-    case TypeID.predicate:
-    case TypeID.function:
-      const argsText = type.args.map((arg) => labelType(arg.type)).join(", ");
-      return `[${argsText}] \u2192 ${labelType(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
-};
-function getTypeClass(typeID) {
-  return TypeIDToClass[typeID];
-}
-function hasGenerics(type) {
-  switch (type.typeID) {
-    case TypeID.anyTypification:
-      return true;
-    case TypeID.integer:
-      return false;
-    case TypeID.basic:
-      return isRadical(type.baseID);
-    case TypeID.collection:
-      return hasGenerics(type.base);
-    case TypeID.tuple:
-      for (const factor of type.factors) {
-        if (hasGenerics(factor)) {
-          return true;
-        }
-      }
-      return false;
-  }
-}
-function checkEquality(type1, type2) {
-  if (type1 === type2) {
-    return true;
-  }
-  if (type1.typeID !== type2.typeID) {
-    return false;
-  }
-  switch (type1.typeID) {
-    case TypeID.integer:
-    case TypeID.anyTypification:
-      return true;
-    case TypeID.basic:
-      return type1.baseID === type2.baseID;
-    case TypeID.collection:
-      return checkEquality(type1.base, type2.base);
-    case TypeID.tuple: {
-      if (type1.factors.length !== type2.factors.length) {
-        return false;
-      }
-      for (let index = 0; index < type1.factors.length; ++index) {
-        if (!checkEquality(type1.factors[index], type2.factors[index])) {
-          return false;
-        }
-      }
-      return true;
-    }
-  }
-}
-function mergeTypifications(type1, type2) {
-  if (type1 === type2) {
-    return type1;
-  }
-  if (type1.typeID === TypeID.anyTypification) {
-    return isTypification(type2) ? type2 : null;
-  }
-  if (type2.typeID === TypeID.anyTypification) {
-    return isTypification(type1) ? type1 : null;
-  }
-  switch (type1.typeID) {
-    case TypeID.integer:
-    case TypeID.basic:
-      return commonType(type1, type2);
-    case TypeID.collection:
-      if (type2.typeID !== TypeID.collection) {
-        return null;
-      }
-      const base = mergeTypifications(type1.base, type2.base);
-      return base ? bool(base) : null;
-    case TypeID.tuple:
-      if (type2.typeID !== TypeID.tuple) {
-        return null;
-      }
-      if (type1.factors.length !== type2.factors.length) {
-        return null;
-      }
-      const components = [];
-      for (let index = 0; index < type1.factors.length; ++index) {
-        const component2 = mergeTypifications(type1.factors[index], type2.factors[index]);
-        if (component2 === null) {
-          return null;
-        }
-        components.push(component2);
-      }
-      return tuple(components);
-  }
-}
-function checkCompatibility(type1, type2) {
-  if (type1 === type2) {
-    return true;
-  }
-  if (type1.typeID === TypeID.anyTypification) {
-    return isTypification(type2);
-  }
-  if (type2.typeID === TypeID.anyTypification) {
-    return isTypification(type1);
-  }
-  if (isTypification(type1) !== isTypification(type2)) {
-    return false;
-  }
-  if (type1.typeID === TypeID.integer || type1.typeID === TypeID.basic || type2.typeID === TypeID.integer || type2.typeID === TypeID.basic) {
-    return commonType(type1, type2) !== null;
-  }
-  if (type1.typeID !== type2.typeID) {
-    return false;
-  }
-  switch (type1.typeID) {
-    case TypeID.collection:
-      return checkCompatibility(type1.base, type2.base);
-    case TypeID.tuple:
-      if (type1.factors.length !== type2.factors.length) {
-        return false;
-      }
-      for (let index = 0; index < type1.factors.length; ++index) {
-        if (!checkCompatibility(type1.factors[index], type2.factors[index])) {
-          return false;
-        }
-      }
-      return true;
-    case TypeID.logic:
-    case TypeID.predicate:
-    case TypeID.function:
-      return false;
-  }
-}
-function compareTemplated(substitutes, arg, value) {
-  if (arg === value) {
-    return true;
-  }
-  if (arg.typeID === TypeID.basic && isRadical(arg.baseID)) {
-    if (!substitutes.has(arg.baseID)) {
-      substitutes.set(arg.baseID, value);
-      return true;
-    } else {
-      const mergeType = mergeTypifications(substitutes.get(arg.baseID), value);
-      if (mergeType === null) {
-        return false;
-      }
-      substitutes.set(arg.baseID, mergeType);
-      return true;
-    }
-  }
-  if (value.typeID === TypeID.anyTypification) {
-    return true;
-  }
-  if (arg.typeID === TypeID.integer || arg.typeID === TypeID.basic || value.typeID === TypeID.integer || value.typeID === TypeID.basic) {
-    return commonType(arg, value) !== null;
-  }
-  if (arg.typeID !== value.typeID) {
-    return false;
-  }
-  switch (arg.typeID) {
-    case TypeID.collection:
-      return compareTemplated(substitutes, arg.base, value.base);
-    case TypeID.tuple: {
-      if (arg.factors.length !== value.factors.length) {
-        return false;
-      }
-      for (let index = 0; index < arg.factors.length; ++index) {
-        if (!compareTemplated(substitutes, arg.factors[index], value.factors[index])) {
-          return false;
-        }
-      }
-      return true;
-    }
-  }
-}
-function substituteBase(target, substitutes) {
-  switch (target.typeID) {
-    case TypeID.basic: {
-      if (substitutes.has(target.baseID)) {
-        Object.assign(target, substitutes.get(target.baseID));
-      }
-      return;
-    }
-    case TypeID.collection: {
-      substituteBase(target.base, substitutes);
-      return;
-    }
-    case TypeID.tuple: {
-      for (const factor of target.factors) {
-        substituteBase(factor, substitutes);
-      }
-      return;
-    }
-  }
-}
-function commonType(type1, type2) {
-  if (type1 === type2) {
-    return type1;
-  }
-  const int1 = "isIntegerCompatible" in type1 && type1.isIntegerCompatible;
-  const int2 = "isIntegerCompatible" in type2 && type2.isIntegerCompatible;
-  if (!int1 || !int2) {
-    if (type1.typeID === TypeID.basic && type2.typeID === TypeID.basic) {
-      return type1.baseID === type2.baseID ? type1 : null;
-    }
-    return null;
-  }
-  if (type1.typeID === TypeID.integer) {
-    return type2;
-  } else if (type2.typeID === TypeID.integer) {
-    return type1;
-  } else {
-    return IntegerT;
-  }
-}
-
-// src/rslang/semantic/type-auditor.ts
-var TypeAuditor = class _TypeAuditor {
-  static TYPE_DEDUCTION_DEPTH = 5;
-  context;
-  reporter;
-  locals;
-  annotateTypes;
-  annotateErrors;
-  constructor(context) {
-    this.annotateTypes = false;
-    this.annotateErrors = false;
-    this.context = context;
-    this.locals = new LocalContext2(this.onError.bind(this));
-  }
-  run(ast, annotateTypes, reporter, annotateErrors = false) {
-    if (ast.hasError) {
-      return null;
-    }
-    this.annotateTypes = annotateTypes;
-    this.annotateErrors = annotateErrors;
-    this.reporter = reporter;
-    this.clear();
-    return this.dispatchVisit(ast);
-  }
-  clear() {
-    this.locals = new LocalContext2(this.onError.bind(this));
-  }
-  dispatchDeclare(node, domain) {
-    const result = this.processDeclare(node, domain);
-    if (result === true && this.annotateTypes) {
-      annotateType(node, domain);
-    }
-    return result;
-  }
-  processDeclare(node, domain) {
-    switch (node.typeID) {
-      case TokenID.ID_LOCAL:
-        return this.declareLocal(node, domain);
-      case TokenID.NT_TUPLE_DECL:
-        return this.declareTuple(node, domain);
-      case TokenID.NT_ENUM_DECL:
-        return this.declareEnumeration(node, domain);
-    }
-    return false;
-  }
-  declareLocal(node, domain) {
-    return this.locals.pushLocal(node, domain);
-  }
-  declareTuple(node, domain) {
-    if (domain.typeID !== TypeID.tuple || domain.factors.length !== node.children.length) {
-      this.onError(RSErrorCode.invalidCortegeDeclare, node.children[0]);
-      return false;
-    }
-    for (let child = 0; child < node.children.length; child++) {
-      if (!this.visitChildDeclaration(node, child, component(domain, child + 1))) {
-        return false;
-      }
-    }
-    return true;
-  }
-  declareEnumeration(node, domain) {
-    for (const child of node.children) {
-      if (!this.dispatchDeclare(child, domain)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  dispatchVisit(node) {
-    const result = this.processVisit(node);
-    if (result !== null && this.annotateTypes) {
-      annotateType(node, result);
-    }
-    return result;
-  }
-  processVisit(node) {
-    switch (node.typeID) {
-      case TokenID.ID_GLOBAL:
-      case TokenID.ID_FUNCTION:
-      case TokenID.ID_PREDICATE:
-        return this.visitGlobal(node);
-      case TokenID.ID_LOCAL:
-        return this.visitLocal(node);
-      case TokenID.ID_RADICAL:
-        return this.visitRadical(node);
-      case TokenID.LIT_INTEGER:
-        return IntegerT;
-      case TokenID.LIT_WHOLE_NUMBERS:
-        return bool(IntegerT);
-      case TokenID.LIT_EMPTYSET:
-        return this.visitEmptySet(node);
-      case TokenID.NT_ARGUMENTS:
-        return this.visitArgumentsEnum(node);
-      case TokenID.NT_ARG_DECL:
-        return this.visitArgument(node);
-      case TokenID.PLUS:
-      case TokenID.MINUS:
-      case TokenID.MULTIPLY:
-        return this.visitArithmetic(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.BIGPR:
-        return this.visitProjectSet(node);
-      case TokenID.SMALLPR:
-        return this.visitProjectTuple(node);
-      case TokenID.FILTER:
-        return this.visitFilter(node);
-      case TokenID.CARD:
-        return this.visitCard(node);
-      case TokenID.REDUCE:
-        return this.visitReduce(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.NT_FUNC_DEFINITION:
-        return this.visitFunctionDefinition(node);
-      case TokenID.NT_FUNC_CALL:
-        return this.visitFunctionCall(node);
-      case TokenID.ITERATE:
-        return this.visitIterate(node);
-      case TokenID.ASSIGN:
-        return this.visitAssign(node);
-      case TokenID.NT_DECLARATIVE_EXPR:
-        return this.visitDeclarative(node);
-      case TokenID.NT_IMPERATIVE_EXPR:
-        return this.visitImperative(node);
-      case TokenID.NT_RECURSIVE_FULL:
-      case TokenID.NT_RECURSIVE_SHORT:
-        return this.visitRecursion(node);
-    }
-    return null;
-  }
-  onError(code, node, params) {
-    this.reporter?.({ code, from: node.from, to: node.to, params });
-    if (this.annotateErrors) {
-      annotateError(node, code, params);
-    }
-    return null;
-  }
-  visitChild(node, index) {
-    if (index >= node.children.length) {
-      return null;
-    }
-    return this.dispatchVisit(node.children[index]);
-  }
-  visitChildDeclaration(node, index, domain) {
-    if (index >= node.children.length) {
-      return false;
-    }
-    if (!this.dispatchDeclare(node.children[index], domain)) {
-      return false;
-    }
-    return true;
-  }
-  visitAllAndReturn(node, type) {
-    for (const child of node.children) {
-      if (!this.dispatchVisit(child)) {
-        return null;
-      }
-    }
-    return type;
-  }
-  childTypification(node, index) {
-    const result = this.visitChild(node, index);
-    if (result === null) {
-      return null;
-    }
-    if (!isTypification(result)) {
-      this.onError(RSErrorCode.expectedSetexpr, node.children[index], [labelType(result)]);
-      return null;
-    }
-    return result;
-  }
-  childLogic(node, index) {
-    const result = this.visitChild(node, index);
-    if (result === null) {
-      return false;
-    }
-    if (result.typeID !== TypeID.logic) {
-      this.onError(RSErrorCode.expectedLogic, node.children[index], [labelType(result)]);
-      return false;
-    }
-    return true;
-  }
-  childTypeDebool(node, index, errorCode) {
-    const result = this.childTypification(node, index);
-    if (result === null) {
-      return null;
-    }
-    if (result.typeID === TypeID.anyTypification) {
-      return result;
-    }
-    if (result.typeID !== TypeID.collection) {
-      this.onError(errorCode, node.children[index], [labelType(result)]);
-      return null;
-    }
-    return debool(result);
-  }
-  visitLocal(node) {
-    return this.locals.getLocalType(node);
-  }
-  visitGlobal(node) {
-    const alias = getNodeText(node);
-    const type = this.context.get(alias);
-    if (!type) {
-      return this.onError(RSErrorCode.globalNotTyped, node, [alias]);
-    }
-    return type;
-  }
-  visitFunctionDefinition(node) {
-    this.locals.startScope();
-    if (!this.visitChild(node, 0)) {
-      return null;
-    }
-    const args = [];
-    for (const local of this.locals.data) {
-      if (local.level === 1) {
-        args.push({ alias: local.alias, type: local.type });
-      }
-    }
-    const result = this.visitChild(node, 1);
-    if (result === null || result.typeID === TypeID.function || result.typeID === TypeID.predicate) {
-      return null;
-    }
-    this.locals.endScope(node.children[1]);
-    if (result.typeID === TypeID.logic) {
-      return {
-        typeID: TypeID.predicate,
-        result,
-        args
-      };
-    } else {
-      return {
-        typeID: TypeID.function,
-        result,
-        args
-      };
-    }
-  }
-  visitFunctionCall(node) {
-    const funcName = getNodeText(node.children[0]);
-    const funcType = this.context.get(funcName);
-    if (funcType?.typeID !== TypeID.function && funcType?.typeID !== TypeID.predicate) {
-      return this.onError(RSErrorCode.globalNotTyped, node.children[0], [funcName]);
-    }
-    if (this.annotateTypes) {
-      annotateType(node.children[0], funcType);
-    }
-    const substitutes = this.checkFuncArguments(node, funcName, funcType);
-    if (substitutes === null) {
-      return null;
-    }
-    if (funcType.result.typeID === TypeID.logic) {
-      return funcType.result;
-    } else {
-      const result = mangleRadicals(funcName, funcType.result);
-      if (substitutes.size > 0) {
-        substituteBase(result, substitutes);
-      }
-      return result;
-    }
-  }
-  visitRadical(node) {
-    const alias = getNodeText(node);
-    if (!this.isInsideFuncArgument(node)) {
-      return this.onError(RSErrorCode.radicalUsage, node, [alias]);
-    }
-    return bool({ typeID: TypeID.basic, baseID: alias });
-  }
-  visitEmptySet(node) {
-    const invalidParents = [
-      TokenID.CARD,
-      TokenID.DEBOOL,
-      TokenID.SET_UNION,
-      TokenID.SET_INTERSECTION,
-      TokenID.SET_MINUS,
-      TokenID.SET_SYMMETRIC_MINUS,
-      TokenID.REDUCE,
-      TokenID.BIGPR,
-      TokenID.SMALLPR
-    ];
-    if (invalidParents.includes(node.parent?.typeID)) {
-      return this.onError(RSErrorCode.invalidEmptySetUsage, node);
-    }
-    return EmptySetT;
-  }
-  visitArgument(node) {
-    const variable = node.children[0];
-    if (variable.typeID === TokenID.NT_TUPLE_DECL) {
-      return this.onError(RSErrorCode.invalidArgumentCortegeDeclare, variable);
-    }
-    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
-    if (domain === null) {
-      return null;
-    }
-    if (!this.visitChildDeclaration(node, 0, domain)) {
-      return null;
-    }
-    return domain;
-  }
-  visitCard(node) {
-    if (!this.childTypeDebool(node, 0, RSErrorCode.invalidCard)) {
-      return null;
-    }
-    return IntegerT;
-  }
-  visitArithmetic(node) {
-    const type1 = this.childTypification(node, 0);
-    if (type1 === null) {
-      return null;
-    }
-    if (!("isArithmetic" in type1 && type1.isArithmetic)) {
-      return this.onError(RSErrorCode.arithmeticNotSupported, node.children[0], [labelType(type1)]);
-    }
-    const type2 = this.childTypification(node, 1);
-    if (type2 === null) {
-      return null;
-    }
-    if (!("isArithmetic" in type2 && type2.isArithmetic)) {
-      return this.onError(RSErrorCode.arithmeticNotSupported, node.children[1], [labelType(type2)]);
-    }
-    const result = mergeTypifications(type1, type2);
-    if (result === null) {
-      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
-    }
-    return result;
-  }
-  visitIntegerPredicate(node) {
-    const type1 = this.childTypification(node, 0);
-    if (type1 === null) {
-      return null;
-    }
-    if (!("isOrdered" in type1 && type1.isOrdered)) {
-      return this.onError(RSErrorCode.orderingNotSupported, node.children[0], [labelType(type1)]);
-    }
-    const type2 = this.childTypification(node, 1);
-    if (type2 === null) {
-      return null;
-    }
-    if (!("isOrdered" in type2 && type2.isOrdered)) {
-      return this.onError(RSErrorCode.orderingNotSupported, node.children[1], [labelType(type2)]);
-    }
-    if (!checkCompatibility(type1, type2)) {
-      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
-    }
-    return LogicT;
-  }
-  visitQuantifier(node) {
-    this.locals.startScope();
-    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
-    if (domain === null) {
-      return null;
-    } else if (!this.visitChildDeclaration(node, 0, domain)) {
-      return null;
-    } else if (!this.childLogic(node, 2)) {
-      return null;
-    }
-    this.locals.endScope(node.children[2]);
-    return LogicT;
-  }
-  visitNegation(node) {
-    if (!this.childLogic(node, 0)) {
-      return null;
-    }
-    return LogicT;
-  }
-  visitLogicBinary(node) {
-    if (!this.childLogic(node, 0) || !this.childLogic(node, 1)) {
-      return null;
-    }
-    return LogicT;
-  }
-  visitEquals(node) {
-    const type1 = this.childTypification(node, 0);
-    if (type1 === null) {
-      return null;
-    }
-    const type2 = this.childTypification(node, 1);
-    if (type2 === null) {
-      return null;
-    }
-    if (!checkCompatibility(type1, type2)) {
-      return this.onError(RSErrorCode.typesNotCompatible, node, [labelType(type1), labelType(type2)]);
-    }
-    return LogicT;
-  }
-  visitSetexprPredicate(node) {
-    let type2 = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
-    if (type2 === null) {
-      return null;
-    }
-    const isSubset = this.isSubset(node.typeID);
-    if (isSubset) {
-      type2 = bool(type2);
-    }
-    const type1 = this.childTypification(node, 0);
-    if (type1 === null) {
-      return null;
-    }
-    if (!checkCompatibility(type1, type2)) {
-      if (isSubset) {
-        return this.onError(RSErrorCode.typesNotEqual, node, [labelType(type1), labelType(type2)]);
-      } else {
-        return this.onError(RSErrorCode.invalidElementPredicate, node, [
-          labelType(type1),
-          labelToken(node.typeID),
-          labelType(bool(type2))
-        ]);
-      }
-    }
-    return LogicT;
-  }
-  visitDecart(node) {
-    const factors = [];
-    for (let child = 0; child < node.children.length; child++) {
-      const type = this.childTypeDebool(node, child, RSErrorCode.invalidDecart);
-      if (type === null) {
-        return null;
-      } else {
-        factors.push(type);
-      }
-    }
-    return bool(tuple(factors));
-  }
-  visitBoolean(node) {
-    const type = this.childTypeDebool(node, 0, RSErrorCode.invalidBoolean);
-    if (type === null) {
-      return null;
-    }
-    return bool(bool(type));
-  }
-  visitTuple(node) {
-    const components = [];
-    for (let child = 0; child < node.children.length; child++) {
-      const type = this.childTypification(node, child);
-      if (type === null) {
-        return null;
-      }
-      components.push(type);
-    }
-    return tuple(components);
-  }
-  visitEnumeration(node) {
-    let type = this.childTypification(node, 0);
-    if (type === null) {
-      return null;
-    }
-    for (let child = 1; child < node.children.length; child++) {
-      const childType = this.childTypification(node, child);
-      if (childType === null) {
-        return null;
-      }
-      const merge = mergeTypifications(type, childType);
-      if (merge === null) {
-        return this.onError(RSErrorCode.invalidEnumeration, node.children[child], [
-          labelType(type),
-          labelType(childType)
-        ]);
-      }
-      type = merge;
-    }
-    return bool(type);
-  }
-  visitBool(node) {
-    return this.visitEnumeration(node);
-  }
-  visitDebool(node) {
-    return this.childTypeDebool(node, 0, RSErrorCode.invalidDebool);
-  }
-  visitSetexprBinary(node) {
-    const type1 = this.childTypeDebool(node, 0, RSErrorCode.invalidTypeOperation);
-    if (type1 === null) {
-      return null;
-    }
-    const type2 = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
-    if (type2 === null) {
-      return null;
-    }
-    const result = mergeTypifications(type1, type2);
-    if (result === null) {
-      return this.onError(RSErrorCode.typesNotEqual, node, [labelType(bool(type1)), labelType(bool(type2))]);
-    }
-    return bool(result);
-  }
-  visitProjectSet(node) {
-    const argument = this.childTypeDebool(node, 0, RSErrorCode.invalidProjectionSet);
-    if (argument === null) {
-      return null;
-    }
-    if (argument.typeID === TypeID.anyTypification) {
-      return EmptySetT;
-    }
-    if (argument.typeID !== TypeID.tuple) {
-      return this.onError(RSErrorCode.invalidProjectionSet, node.children[0], [
-        labelRSLangNode(node),
-        labelType(bool(argument))
-      ]);
-    }
-    const indices = getNodeIndices(node);
-    const components = [];
-    for (const index of indices) {
-      const newComponent = component(argument, index);
-      if (newComponent === null) {
-        return this.onError(RSErrorCode.invalidProjectionSet, node.children[0], [
-          labelRSLangNode(node),
-          labelType(bool(argument))
-        ]);
-      } else {
-        components.push(newComponent);
-      }
-    }
-    if (components.length === 1) {
-      return bool(components[0]);
-    } else {
-      return bool(tuple(components));
-    }
-  }
-  visitProjectTuple(node) {
-    const argument = this.childTypification(node, 0);
-    if (argument === null) {
-      return null;
-    }
-    if (argument.typeID === TypeID.anyTypification) {
-      return argument;
-    }
-    if (argument.typeID !== TypeID.tuple) {
-      return this.onError(RSErrorCode.invalidProjectionTuple, node.children[0], [
-        labelRSLangNode(node),
-        labelType(argument)
-      ]);
-    }
-    const indices = getNodeIndices(node);
-    const components = [];
-    for (const index of indices) {
-      const newComponent = component(argument, index);
-      if (newComponent === null) {
-        return this.onError(RSErrorCode.invalidProjectionTuple, node.children[0], [
-          labelRSLangNode(node),
-          labelType(argument)
-        ]);
-      } else {
-        components.push(newComponent);
-      }
-    }
-    if (components.length === 1) {
-      return components[0];
-    } else {
-      return tuple(components);
-    }
-  }
-  visitFilter(node) {
-    const indices = getNodeIndices(node);
-    const tupleParam = indices.length === node.children.length - 1;
-    if (!tupleParam && node.children.length > 2) {
-      return this.onError(RSErrorCode.invalidFilterArity, node);
-    }
-    const argument = this.childTypification(node, node.children.length - 1);
-    if (argument === null) {
-      return null;
-    }
-    if (argument.typeID === TypeID.anyTypification || argument.typeID === TypeID.collection && argument.base.typeID === TypeID.anyTypification) {
-      return EmptySetT;
-    }
-    if (argument.typeID !== TypeID.collection || argument.base.typeID !== TypeID.tuple) {
-      return this.onError(RSErrorCode.invalidFilterArgumentType, node.children[node.children.length - 1], [
-        labelRSLangNode(node),
-        labelType(argument)
-      ]);
-    }
-    const argBase = debool(argument);
-    const bases = [];
-    for (const index of indices) {
-      const newBase = component(argBase, index);
-      if (newBase === null) {
-        return this.onError(RSErrorCode.invalidFilterArgumentType, node.children[node.children.length - 1], [
-          labelRSLangNode(node),
-          labelType(argument)
-        ]);
-      }
-      bases.push(newBase);
-    }
-    if (tupleParam) {
-      for (let child = 0; child + 1 < node.children.length; child++) {
-        const param = this.childTypification(node, child);
-        if (param === null) {
-          return null;
-        }
-        if (param.typeID !== TypeID.collection || !checkCompatibility(bases[child], debool(param))) {
-          return this.onError(RSErrorCode.typesNotEqual, node.children[child], [
-            labelType(param),
-            labelType(bool(bases[child]))
-          ]);
-        }
-      }
-    } else {
-      const param = this.childTypification(node, 0);
-      if (param === null) {
-        return null;
-      }
-      const paramType = param;
-      const expected = bool(tuple(bases));
-      if (paramType.typeID !== TypeID.collection || !checkCompatibility(expected, paramType)) {
-        return this.onError(RSErrorCode.typesNotEqual, node.children[0], [labelType(paramType), labelType(expected)]);
-      }
-    }
-    return argument;
-  }
-  visitReduce(node) {
-    const argument = this.childTypification(node, 0);
-    if (argument === null) {
-      return null;
-    }
-    if (argument.typeID === TypeID.anyTypification || argument.typeID === TypeID.collection && argument.base.typeID === TypeID.anyTypification) {
-      return EmptySetT;
-    }
-    if (argument.typeID !== TypeID.collection || argument.base.typeID !== TypeID.collection) {
-      return this.onError(RSErrorCode.invalidReduce, node.children[0], [labelType(argument)]);
-    }
-    return debool(argument);
-  }
-  visitArgumentsEnum(node) {
-    return this.visitAllAndReturn(node, LogicT);
-  }
-  visitDeclarative(node) {
-    this.locals.startScope();
-    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
-    if (domain === null) {
-      return null;
-    } else if (!this.visitChildDeclaration(node, 0, domain)) {
-      return null;
-    } else if (!this.childLogic(node, 2)) {
-      return null;
-    }
-    this.locals.endScope(node.children[2]);
-    return bool(domain);
-  }
-  visitImperative(node) {
-    this.locals.startScope();
-    for (let child = 1; child < node.children.length; child++) {
-      if (!this.childLogic(node, child)) {
-        return null;
-      }
-    }
-    const type = this.childTypification(node, 0);
-    if (type === null) {
-      return null;
-    }
-    this.locals.endScope(node);
-    return bool(type);
-  }
-  visitIterate(node) {
-    const domain = this.childTypeDebool(node, 1, RSErrorCode.invalidTypeOperation);
-    if (domain === null) {
-      return null;
-    }
-    if (!this.visitChildDeclaration(node, 0, domain)) {
-      return null;
-    }
-    return LogicT;
-  }
-  visitAssign(node) {
-    const domain = this.childTypification(node, 1);
-    if (domain === null) {
-      return null;
-    }
-    if (!this.visitChildDeclaration(node, 0, domain)) {
-      return null;
-    }
-    return LogicT;
-  }
-  visitRecursion(node) {
-    this.locals.startScope();
-    const initType = this.childTypification(node, 1);
-    if (initType === null) {
-      return null;
-    }
-    if (!this.visitChildDeclaration(node, 0, initType)) {
-      return null;
-    }
-    const isFull = node.typeID === TokenID.NT_RECURSIVE_FULL;
-    const iterationIndex = isFull ? 3 : 2;
-    let iterationValue = this.childTypification(node, iterationIndex);
-    if (iterationValue === null) {
-      return null;
-    }
-    if (!checkCompatibility(iterationValue, initType)) {
-      return this.onError(RSErrorCode.typesNotEqual, node.children[iterationIndex], [
-        labelType(iterationValue),
-        labelType(initType)
-      ]);
-    }
-    if (hasGenerics(initType)) {
-      for (let retries = _TypeAuditor.TYPE_DEDUCTION_DEPTH; retries > 0; retries--) {
-        this.locals.endScope(node);
-        this.locals.clearUnused();
-        this.locals.startScope();
-        if (!this.visitChildDeclaration(node, 0, iterationValue)) {
-          return null;
-        }
-        const newIteration = this.childTypification(node, iterationIndex);
-        if (newIteration === null) {
-          return null;
-        }
-        if (checkEquality(newIteration, iterationValue)) {
-          break;
-        }
-        iterationValue = newIteration;
-      }
-    }
-    if (isFull) {
-      if (!this.childLogic(node, 2)) {
-        return null;
-      }
-    }
-    this.locals.endScope(node);
-    return iterationValue;
-  }
-  isSubset(token) {
-    return token === TokenID.SUBSET || token === TokenID.SUBSET_OR_EQ || token === TokenID.NOT_SUBSET;
-  }
-  isInsideFuncArgument(node) {
-    while (node.parent && node.parent !== node) {
-      if (node.typeID === TokenID.NT_ARGUMENTS) return true;
-      node = node.parent;
-    }
-    return false;
-  }
-  checkFuncArguments(node, alias, type) {
-    if (node.children.length - 1 !== type.args.length) {
-      return this.onError(RSErrorCode.invalidArgsArity, node.children[1], [
-        String(type.args.length),
-        String(node.children.length - 1)
-      ]);
-    }
-    const substitutes = /* @__PURE__ */ new Map();
-    for (let child = 1; child < node.children.length; child++) {
-      const childType = this.childTypification(node, child);
-      if (childType === null) {
-        return null;
-      }
-      const argType = mangleRadicals(alias, type.args[child - 1].type);
-      if (!compareTemplated(substitutes, argType, childType)) {
-        this.onError(RSErrorCode.invalidArgumentType, node.children[child], [
-          `${type.args[child - 1].alias}\u2208${labelType(argType)}`,
-          labelType(childType)
-        ]);
-        return null;
-      }
-    }
-    return substitutes;
-  }
-};
-function mangleRadicals(funcName, type) {
-  switch (type.typeID) {
-    default:
-      throw new Error(`Unexpected type: ${type.typeID}`);
-    case TypeID.integer:
-      return type;
-    case TypeID.basic: {
-      if (isRadical(type.baseID)) {
-        return {
-          typeID: type.typeID,
-          baseID: type.baseID + funcName
-        };
-      }
-      return type;
-    }
-    case TypeID.collection: {
-      return {
-        typeID: type.typeID,
-        base: mangleRadicals(funcName, debool(type))
-      };
-    }
-    case TypeID.tuple: {
-      const factors = [];
-      for (let index = 1; index <= type.factors.length; ++index) {
-        factors.push(mangleRadicals(funcName, component(type, index)));
-      }
-      return {
-        typeID: type.typeID,
-        factors
-      };
-    }
-  }
-}
-var LocalContext2 = class {
-  onError;
-  data = [];
-  constructor(onError) {
-    this.onError = onError;
-  }
-  startScope() {
-    for (const local of this.data) {
-      if (local.level > 0) {
-        local.level = local.level + 1;
-      }
-    }
-  }
-  endScope(node, skipUnused = false) {
-    for (const local of this.data) {
-      local.level--;
-      if (!skipUnused && local.level === 0 && local.useCount === 0) {
-        this.onError(RSErrorCode.localNotUsed, node, [local.alias]);
-      }
-    }
-  }
-  clearUnused() {
-    this.data = this.data.filter((data) => data.level > 0);
-  }
-  pushLocal(node, type) {
-    const alias = getNodeText(node);
-    const existing = this.data.find((data) => data.alias === alias);
-    if (existing) {
-      if (existing.level > 0) {
-        this.onError(RSErrorCode.localShadowing, node, [alias]);
-        return false;
-      } else {
-        this.onError(RSErrorCode.localDoubleDeclare, node, [alias]);
-        const index = this.data.indexOf(existing);
-        if (index !== -1) {
-          this.data.splice(index, 1);
-        }
-      }
-    }
-    this.data.push({ alias, type, level: 1, useCount: 0 });
-    return true;
-  }
-  getLocalType(node) {
-    const alias = getNodeText(node);
-    const local = this.data.find((data) => data.alias === alias);
-    if (local === void 0) {
-      this.onError(RSErrorCode.localUndeclared, node, [alias]);
-      return null;
-    } else if (local.level < 1) {
-      this.onError(RSErrorCode.localOutOfScope, node, [alias]);
-      return null;
-    } else {
-      local.useCount++;
-      return local.type;
-    }
-  }
-};
-
-// src/rslang/semantic/value-class.ts
-var ValueClass = {
-  VALUE: "value",
-  PROPERTY: "property"
-};
-
-// src/rslang/semantic/value-auditor.ts
-var ValueAuditor = class {
-  context;
-  annotateErrors;
-  reporter;
-  constructor(context) {
-    this.context = context;
-    this.annotateErrors = false;
-  }
-  /**
-   * Runs value audit on the AST. Returns the value class on success, null on failure.
-   */
-  run(ast, reporter, annotateErrors = false) {
-    if (ast.hasError) {
-      return null;
-    }
-    this.reporter = reporter;
-    this.annotateErrors = annotateErrors;
-    return this.dispatchVisit(ast);
-  }
-  dispatchVisit(node) {
-    switch (node.typeID) {
-      case TokenID.ID_GLOBAL:
-      case TokenID.ID_FUNCTION:
-      case TokenID.ID_PREDICATE:
-        return this.visitGlobal(node);
-      case TokenID.ID_LOCAL:
-      case TokenID.ID_RADICAL:
-      case TokenID.LIT_INTEGER:
-      case TokenID.LIT_EMPTYSET:
-        return ValueClass.VALUE;
-      case TokenID.LIT_WHOLE_NUMBERS:
-        return ValueClass.PROPERTY;
-      case TokenID.NT_TUPLE_DECL:
-      case TokenID.NT_ENUM_DECL:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.NT_ARGUMENTS:
-      case TokenID.NT_ARG_DECL:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.PLUS:
-      case TokenID.MINUS:
-      case TokenID.MULTIPLY:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.QUANTOR_UNIVERSAL:
-      case TokenID.QUANTOR_EXISTS:
-        return this.visitQuantifier(node);
-      case TokenID.LOGIC_NOT:
-      case TokenID.LOGIC_AND:
-      case TokenID.LOGIC_OR:
-      case TokenID.LOGIC_IMPLICATION:
-      case TokenID.LOGIC_EQUIVALENT:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.EQUAL:
-      case TokenID.NOTEQUAL:
-        return this.assertAllValues(node);
-      case TokenID.GREATER:
-      case TokenID.LESSER:
-      case TokenID.GREATER_OR_EQ:
-      case TokenID.LESSER_OR_EQ:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      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:
-      case TokenID.NT_ENUMERATION:
-        return this.assertAllValues(node);
-      case TokenID.FILTER:
-        return this.visitFilter(node);
-      case TokenID.CARD:
-      case TokenID.BOOL:
-      case TokenID.DEBOOL:
-      case TokenID.BIGPR:
-      case TokenID.SMALLPR:
-      case TokenID.REDUCE:
-        return this.assertChildIsValue(node, 0);
-      case TokenID.SET_UNION:
-      case TokenID.SET_INTERSECTION:
-      case TokenID.SET_MINUS:
-      case TokenID.SET_SYMMETRIC_MINUS:
-        return this.visitSetexprBinary(node);
-      case TokenID.NT_FUNC_DEFINITION:
-        return this.visitFunctionDefinition(node);
-      case TokenID.NT_FUNC_CALL:
-        return this.visitFunctionCall(node);
-      case TokenID.NT_DECLARATIVE_EXPR:
-        return this.visitDeclarative(node);
-      case TokenID.NT_IMPERATIVE_EXPR:
-        return this.visitImperative(node);
-      case TokenID.NT_RECURSIVE_FULL:
-      case TokenID.NT_RECURSIVE_SHORT:
-        return this.assertAllValues(node);
-      case TokenID.ITERATE:
-      case TokenID.ASSIGN:
-        return this.visitIterateOrAssign(node);
-    }
-    return null;
-  }
-  onError(code, node, params) {
-    this.reporter?.({ code, from: node.from, to: node.to, params });
-    if (this.annotateErrors) {
-      annotateError(node, code, params);
-    }
-    return null;
-  }
-  visitChild(node, index) {
-    return this.dispatchVisit(node.children[index]);
-  }
-  visitAllAndReturn(node, value) {
-    for (const child of node.children) {
-      if (this.dispatchVisit(child) === null) {
-        return null;
-      }
-    }
-    return value;
-  }
-  assertChildIsValue(node, index) {
-    const result = this.visitChild(node, index);
-    if (result === null) {
-      return null;
-    }
-    if (result !== ValueClass.VALUE) {
-      const child = node.children[index];
-      return this.onError(RSErrorCode.invalidPropertyUsage, child ?? node);
-    }
-    return ValueClass.VALUE;
-  }
-  assertAllValues(node) {
-    for (let i = 0; i < node.children.length; i++) {
-      if (this.assertChildIsValue(node, i) === null) {
-        return null;
-      }
-    }
-    return ValueClass.VALUE;
-  }
-  visitFunctionDefinition(node) {
-    if (this.visitChild(node, 0) === null) {
-      return null;
-    }
-    return this.visitChild(node, 1);
-  }
-  visitFunctionCall(node) {
-    const result = this.visitChild(node, 0);
-    if (result === null) {
-      return null;
-    }
-    for (let child = 1; child < node.children.length; child++) {
-      if (this.assertChildIsValue(node, child) === null) {
-        return null;
-      }
-    }
-    return result;
-  }
-  visitGlobal(node) {
-    const alias = getNodeText(node);
-    const result = this.context.get(alias);
-    if (!result) {
-      return this.onError(RSErrorCode.globalNoValue, node, [alias]);
-    }
-    return result;
-  }
-  visitQuantifier(node) {
-    if (this.assertChildIsValue(node, 1) === null) {
-      return null;
-    }
-    if (this.visitChild(node, 2) === null) {
-      return null;
-    }
-    return ValueClass.VALUE;
-  }
-  visitSetexprPredicate(node) {
-    const tokenId = node.typeID;
-    switch (tokenId) {
-      case TokenID.SET_IN:
-      case TokenID.SET_NOT_IN:
-      case TokenID.SUBSET_OR_EQ:
-        if (this.assertChildIsValue(node, 0) === null) {
-          return null;
-        }
-        if (this.visitChild(node, 1) === null) {
-          return null;
-        }
-        return ValueClass.VALUE;
-      case TokenID.SUBSET:
-      case TokenID.NOT_SUBSET:
-        return this.assertAllValues(node);
-    }
-    return null;
-  }
-  visitDeclarative(node) {
-    if (this.visitChild(node, 2) === null) {
-      return null;
-    }
-    return this.visitChild(node, 1);
-  }
-  visitImperative(node) {
-    for (let child = 1; child < node.children.length; child++) {
-      if (this.visitChild(node, child) === null) {
-        return null;
-      }
-    }
-    return this.assertChildIsValue(node, 0);
-  }
-  visitIterateOrAssign(node) {
-    if (this.visitChild(node, 0) === null) {
-      return null;
-    }
-    return this.assertChildIsValue(node, 1);
-  }
-  visitDecart(node) {
-    let result = ValueClass.VALUE;
-    for (let child = 0; child < node.children.length; child++) {
-      const childClass = this.visitChild(node, child);
-      if (childClass === null) {
-        return null;
-      }
-      if (childClass === ValueClass.PROPERTY) {
-        result = ValueClass.PROPERTY;
-      }
-    }
-    return result;
-  }
-  visitBoolean(node) {
-    if (this.visitChild(node, 0) === null) {
-      return null;
-    }
-    return ValueClass.PROPERTY;
-  }
-  visitFilter(node) {
-    let last = null;
-    for (const child of node.children) {
-      last = this.dispatchVisit(child);
-      if (last === null) {
-        return null;
-      }
-    }
-    return last;
-  }
-  visitSetexprBinary(node) {
-    const first = this.visitChild(node, 0);
-    if (first === null) {
-      return null;
-    }
-    const second = this.visitChild(node, 1);
-    if (second === null) {
-      return null;
-    }
-    const isValue = combineOperationValues(
-      node.typeID,
-      first === ValueClass.VALUE,
-      second === ValueClass.VALUE
-    );
-    return isValue ? ValueClass.VALUE : ValueClass.PROPERTY;
-  }
-};
-function combineOperationValues(op, v1, v2) {
-  switch (op) {
-    case TokenID.SET_SYMMETRIC_MINUS:
-    case TokenID.SET_UNION:
-      return v1 && v2;
-    case TokenID.SET_INTERSECTION:
-      return v1 || v2;
-    case TokenID.SET_MINUS:
-      return v1;
-    default:
-      return v1 && v2;
-  }
-}
-
-// src/rslang/semantic/analyzer.ts
-var RSLangAnalyzer = class {
-  typeContext = /* @__PURE__ */ new Map();
-  valueContext = /* @__PURE__ */ new Map();
-  typeAuditor = new TypeAuditor(this.typeContext);
-  valueAuditor = new ValueAuditor(this.valueContext);
-  addBase(alias, isNumeric = false, valueClass = ValueClass.VALUE) {
-    if (isNumeric) {
-      this.typeContext.set(alias, bool(constant(alias)));
-      this.valueContext.set(alias, valueClass);
-    } else {
-      this.typeContext.set(alias, bool(basic(alias)));
-      this.valueContext.set(alias, valueClass);
-    }
-  }
-  setGlobal(alias, type, value) {
-    if (type) {
-      this.typeContext.set(alias, type);
-    }
-    if (value) {
-      this.valueContext.set(alias, value);
-    }
-  }
-  getType(alias) {
-    return this.typeContext.get(alias) ?? null;
-  }
-  checkFast(expression, options) {
-    if (expression.length === 0) {
-      return { success: false, type: null, valueClass: null, ast: null };
-    }
-    const ast = this.parse(expression);
-    if (ast.hasError) {
-      return { success: false, type: null, valueClass: null, ast };
-    }
-    const type = this.typeAuditor.run(ast, options?.annotateTypes ?? false);
-    if (type === null) {
-      return { success: false, type: null, valueClass: null, ast };
-    }
-    if (options?.isDomain) {
-      if (!isStructureDomain(ast) || type.typeID !== TypeID.collection) {
-        return { success: false, type: null, valueClass: null, ast };
-      }
-      return { success: true, type: debool(type), valueClass: ValueClass.VALUE, ast };
-    }
-    if (options?.expected && getTypeClass(type.typeID) !== options.expected) {
-      return { success: false, type: null, valueClass: null, ast };
-    }
-    return {
-      success: true,
-      type,
-      valueClass: options?.isDomain ? ValueClass.VALUE : this.valueAuditor.run(ast),
-      ast
-    };
-  }
-  checkFull(expression, options) {
-    const errors = [];
-    const reporter = (error) => {
-      errors.push(error);
-    };
-    if (expression.length === 0) {
-      reporter({ code: RSErrorCode.cstEmptyDerived, from: 0, to: 0 });
-      return { success: false, type: null, valueClass: null, errors, ast: null };
-    }
-    const ast = this.parse(expression);
-    if (ast.hasError) {
-      extractSyntaxErrors(ast, expression, reporter, options?.annotateErrors ?? false);
-      return { success: false, type: null, valueClass: null, errors, ast };
-    }
-    const type = this.typeAuditor.run(ast, options?.annotateTypes ?? false, reporter, options?.annotateErrors ?? false);
-    if (type === null) {
-      return { success: false, type: null, valueClass: null, errors, ast };
-    }
-    if (options?.isDomain) {
-      if (!isStructureDomain(ast) || type.typeID !== TypeID.collection) {
-        reporter({ code: RSErrorCode.globalStructure, from: ast.from, to: ast.to });
-        if (options?.annotateErrors) {
-          annotateError(ast, RSErrorCode.globalStructure);
-        }
-        return { success: false, type: null, valueClass: null, errors, ast };
-      }
-      return { success: true, type: debool(type), valueClass: ValueClass.VALUE, errors, ast };
-    }
-    if (options?.expected && getTypeClass(type.typeID) !== options.expected) {
-      reporter({
-        code: RSErrorCode.expectedType,
-        from: ast.from,
-        to: ast.to
-      });
-      if (options?.annotateErrors) {
-        annotateError(ast, RSErrorCode.expectedType);
-      }
-      return { success: false, type: null, valueClass: null, errors, ast };
-    }
-    const valueClass = options?.isDomain ? ValueClass.VALUE : this.valueAuditor.run(ast, reporter, options?.annotateErrors ?? false);
-    return { success: true, type, valueClass, errors, ast };
-  }
-  parse(expression) {
-    const tree = parser.parse(expression);
-    const ast = buildTree(tree.cursor());
-    normalizeAST(ast, expression);
-    return ast;
-  }
-};
-function isStructureDomain(node) {
-  switch (node.typeID) {
-    case TokenID.LIT_WHOLE_NUMBERS:
-    case TokenID.ID_GLOBAL:
-    case TokenID.BOOLEAN:
-    case TokenID.DECART:
-    case TokenID.NT_ENUMERATION:
-      break;
-    default:
-      return false;
-  }
-  for (const child of node.children) {
-    if (!isStructureDomain(child)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// src/rslang/semantic/typification-parser.ts
-function parseTypeText(input) {
-  const normalized = input.trim().replaceAll("->", "\u2192");
-  if (normalized.length === 0) {
-    return { type: null, error: null };
-  }
-  const parser2 = new TypificationParser(normalized);
-  return parser2.parse();
-}
-function applyAsciiTypeSubstitutions(raw) {
-  return raw.replaceAll("->", "\u2192").replaceAll("*", "\xD7").replaceAll("B", "\u212C");
-}
-var TypificationParser = class {
-  index = 0;
-  input;
-  constructor(input) {
-    this.index = 0;
-    this.input = input;
-  }
-  parse() {
-    try {
-      const result = this.parseExpressionType();
-      this.skipSpaces();
-      if (!this.eof()) {
-        throw new Error("Unexpected trailing symbols");
-      }
-      return { type: result, error: null };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return { type: null, error: message };
-    }
-  }
-  parseExpressionType() {
-    this.skipSpaces();
-    if (this.peek() === "[") {
-      return this.parseCallableType();
-    } else {
-      return this.parseTypification();
-    }
-  }
-  parseCallableType() {
-    this.expect("[");
-    const args = [];
-    this.skipSpaces();
-    if (this.peek() !== "]") {
-      while (true) {
-        args.push(this.parseTypification());
-        this.skipSpaces();
-        if (this.peek() === ",") {
-          this.next();
-          this.skipSpaces();
-          if (this.peek() === "]") {
-            throw new Error("Empty argument in callable typification");
-          }
-          continue;
-        }
-        break;
-      }
-    }
-    this.expect("]");
-    this.skipSpaces();
-    this.expect("\u2192");
-    const result = this.parseCallableResult();
-    if (result.typeID === TypeID.logic) {
-      return {
-        typeID: TypeID.predicate,
-        result: LogicT,
-        args: args.map((arg, index) => ({ alias: `a${index + 1}`, type: arg }))
-      };
-    }
-    if (!isTypification(result)) {
-      throw new Error("Invalid callable result type");
-    }
-    return {
-      typeID: TypeID.function,
-      result,
-      args: args.map((arg, index) => ({ alias: `a${index + 1}`, type: arg }))
-    };
-  }
-  parseCallableResult() {
-    this.skipSpaces();
-    const lookahead = this.readToken();
-    this.index -= lookahead.length;
-    if (lookahead === "Logic") {
-      this.index += lookahead.length;
-      return LogicT;
-    }
-    return this.parseTypification();
-  }
-  parseTypification() {
-    this.skipSpaces();
-    if (this.match("\u212C")) {
-      this.skipSpaces();
-      if (this.peek() === "(") {
-        this.next();
-        const base = this.parseTypification();
-        this.expect(")");
-        return bool(base);
-      }
-      this.skipSpaces();
-      if (this.input.startsWith("\u212C", this.index)) {
-        const base = this.parseTypification();
-        return bool(base);
-      }
-      throw new Error('Expected "(" after "\u212C"');
-    }
-    const first = this.parseTypificationAtom();
-    const factors = [first];
-    while (true) {
-      this.skipSpaces();
-      if (!this.match("\xD7")) {
-        break;
-      }
-      factors.push(this.parseTypificationAtom());
-    }
-    if (factors.length === 1) {
-      return first;
-    }
-    return tuple(factors);
-  }
-  parseTypificationAtom() {
-    this.skipSpaces();
-    if (this.input.startsWith("\u212C", this.index)) {
-      return this.parseTypification();
-    }
-    if (this.peek() === "(") {
-      this.next();
-      const wrapped = this.parseTypification();
-      this.expect(")");
-      return wrapped;
-    }
-    const token = this.readToken();
-    if (token === "Z") {
-      return IntegerT;
-    }
-    if (token === "R0") {
-      return { typeID: TypeID.anyTypification };
-    }
-    if (!/^[A-Z]\d+$/.test(token)) {
-      throw new Error(`Unknown typification token "${token}"`);
-    }
-    return { typeID: TypeID.basic, baseID: token };
-  }
-  readToken() {
-    this.skipSpaces();
-    const start = this.index;
-    while (!this.eof()) {
-      const char = this.peek();
-      if (!char || /[\s,()[\]→×]/.test(char)) {
-        break;
-      }
-      this.next();
-    }
-    if (start === this.index) {
-      throw new Error("Expected typification token");
-    }
-    return this.input.slice(start, this.index);
-  }
-  skipSpaces() {
-    while (!this.eof() && /\s/.test(this.peek())) {
-      this.index += 1;
-    }
-  }
-  expect(symbol) {
-    this.skipSpaces();
-    if (!this.match(symbol)) {
-      throw new Error(`Expected "${symbol}"`);
-    }
-  }
-  match(symbol) {
-    if (this.input.startsWith(symbol, this.index)) {
-      this.index += symbol.length;
-      return true;
-    }
-    return false;
-  }
-  peek() {
-    return this.input[this.index];
-  }
-  next() {
-    const value = this.input[this.index];
-    this.index += 1;
-    return value;
-  }
-  eof() {
-    return this.index >= this.input.length;
-  }
-};
-
-// src/rslang/typification-graph.ts
-var TypificationGraph = class {
-  /** List of nodes. */
-  nodes = [];
-  /** Map of nodes by ID. */
-  nodeById = /* @__PURE__ */ new Map();
-  /** Map of nodes by alias. */
-  nodeByAlias = /* @__PURE__ */ new Map();
-  /** Adds an element to the graph. */
-  addElement(alias, type) {
-    const node = this.processType(type);
-    if (!node) {
-      return;
-    }
-    this.addAliasAnnotation(node.id, alias);
-  }
-  processType(type) {
-    switch (type.typeID) {
-      case TypeID.logic:
-        return null;
-      case TypeID.anyTypification:
-      case TypeID.integer:
-      case TypeID.basic:
-        return this.addBaseNode(type);
-      case TypeID.collection:
-        return this.addBooleanNode(type);
-      case TypeID.tuple:
-        return this.addCartesianNode(type);
-      case TypeID.function:
-      case TypeID.predicate:
-        const combined = convertFunctionToTypification(type);
-        if (!combined) {
-          return null;
-        }
-        return this.processType(combined);
-    }
-  }
-  addBaseNode(type) {
-    const text = labelType(type);
-    const existingNode = this.nodes.find((node2) => node2.text === text);
-    if (existingNode) {
-      return existingNode;
-    }
-    const node = {
-      id: this.nodes.length,
-      text,
-      rank: 0,
-      parents: [],
-      annotations: []
-    };
-    this.nodes.push(node);
-    this.nodeById.set(node.id, node);
-    return node;
-  }
-  addBooleanNode(type) {
-    const baseNode = this.processType(type.base);
-    if (!baseNode) {
-      return null;
-    }
-    const existingNode = this.nodes.find((node2) => node2.parents.length === 1 && node2.parents[0] === baseNode.id);
-    if (existingNode) {
-      return existingNode;
-    }
-    const node = {
-      id: this.nodes.length,
-      rank: baseNode.rank + 1,
-      text: labelType(type),
-      parents: [baseNode.id],
-      annotations: []
-    };
-    this.nodes.push(node);
-    this.nodeById.set(node.id, node);
-    return node;
-  }
-  addCartesianNode(type) {
-    const factors = type.factors.map((factor) => this.processType(factor)).filter((factor) => factor !== null);
-    if (factors.length !== type.factors.length) {
-      return null;
-    }
-    const existingNode = this.nodes.find(
-      (node2) => node2.parents.length === factors.length && node2.parents.every((p, i) => p === factors[i].id)
-    );
-    if (existingNode) {
-      return existingNode;
-    }
-    const node = {
-      id: this.nodes.length,
-      text: labelType(type),
-      rank: Math.max(...factors.map((factor) => factor.rank)) + 1,
-      parents: factors.map((factor) => factor.id),
-      annotations: []
-    };
-    this.nodes.push(node);
-    this.nodeById.set(node.id, node);
-    return node;
-  }
-  addAliasAnnotation(node, alias) {
-    const nodeToAnnotate = this.nodeById.get(node);
-    if (!nodeToAnnotate) {
-      throw new Error(`Node ${node} not found`);
-    }
-    nodeToAnnotate.annotations.push(alias);
-    this.nodeByAlias.set(alias, nodeToAnnotate);
-  }
-};
-function convertFunctionToTypification(type) {
-  if (!("args" in type) || type.args.length === 0) {
-    return null;
-  }
-  const args = type.args.length === 1 ? type.args[0].type : tuple(type.args.map((arg) => arg.type));
-  if (type.result.typeID === TypeID.logic) {
-    return bool(args);
-  } else {
-    return bool(tuple([type.result, args]));
-  }
-}
-export {
-  AnyTypificationT,
-  EmptySetT,
-  LogicT,
-  RSCalculator,
-  RSErrorCode,
-  RSLangAnalyzer,
-  TokenID,
-  TypeClass,
-  TypeID,
-  TypificationGraph,
-  ValueClass,
-  applyAsciiTypeSubstitutions,
-  makeTypePath,
-  makeValuePath,
-  parseTypeText,
-  printValue,
-  readErrorAnnotation,
-  readTypeAnnotation,
-  parser as rslangParser
-};
-//# sourceMappingURL=index.js.map
+import { readErrorAnnotation, readTypeAnnotation } from "./ast-annotations.js";
+import { RSErrorCode } from "./error.js";
+import { TokenID } from "./parser/token.js";
+import { AnyTypificationT, EmptySetT, LogicT, TypeClass, TypeID, makeTypePath } from "./semantic/typification.js";
+import { S as printValue, l as makeValuePath } from "../value-B8UtCqaK.js";
+import { RSCalculator } from "./eval/calculator.js";
+import { parser } from "./parser/parser.js";
+import { ValueClass } from "./semantic/value-class.js";
+import { RSLangAnalyzer } from "./semantic/analyzer.js";
+import { applyAsciiTypeSubstitutions, parseTypeText } from "./semantic/typification-parser.js";
+import { TypificationGraph } from "./typification-graph.js";
+export { AnyTypificationT, EmptySetT, LogicT, RSCalculator, RSErrorCode, RSLangAnalyzer, TokenID, TypeClass, TypeID, TypificationGraph, ValueClass, applyAsciiTypeSubstitutions, makeTypePath, makeValuePath, parseTypeText, printValue, readErrorAnnotation, readTypeAnnotation, parser as rslangParser };